import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AdapterApi;

import java.io.File;
import java.util.*;

public class AdapterApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        AdapterApi apiInstance = new AdapterApi();
        String subnetId = subnetId_example; // String | The ID of the network subnet.
        Adapter adapter = ; // Adapter | 
        Boolean assignIP = true; // Boolean | Whether Kowabunga should pick and assign an IP address to this adapter.

        try {
            Adapter result = apiInstance.createAdapter(subnetId, adapter, assignIP);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdapterApi#createAdapter");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String subnetId = new String(); // String | The ID of the network subnet.
final Adapter adapter = new Adapter(); // Adapter | 
final Boolean assignIP = new Boolean(); // Boolean | Whether Kowabunga should pick and assign an IP address to this adapter.

try {
    final result = await api_instance.createAdapter(subnetId, adapter, assignIP);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->createAdapter: $e\n');
}

import org.openapitools.client.api.AdapterApi;

public class AdapterApiExample {
    public static void main(String[] args) {
        AdapterApi apiInstance = new AdapterApi();
        String subnetId = subnetId_example; // String | The ID of the network subnet.
        Adapter adapter = ; // Adapter | 
        Boolean assignIP = true; // Boolean | Whether Kowabunga should pick and assign an IP address to this adapter.

        try {
            Adapter result = apiInstance.createAdapter(subnetId, adapter, assignIP);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdapterApi#createAdapter");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
AdapterApi *apiInstance = [[AdapterApi alloc] init];
String *subnetId = subnetId_example; // The ID of the network subnet. (default to null)
Adapter *adapter = ; // 
Boolean *assignIP = true; // Whether Kowabunga should pick and assign an IP address to this adapter. (optional) (default to null)

[apiInstance createAdapterWith:subnetId
    adapter:adapter
    assignIP:assignIP
              completionHandler: ^(Adapter output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KowabungaApiDocumentation = require('kowabunga_api_documentation');
var defaultClient = KowabungaApiDocumentation.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new KowabungaApiDocumentation.AdapterApi()
var subnetId = subnetId_example; // {String} The ID of the network subnet.
var adapter = ; // {Adapter} 
var opts = {
  'assignIP': true // {Boolean} Whether Kowabunga should pick and assign an IP address to this adapter.
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createAdapter(subnetId, adapter, opts, callback);

using System;
using System.Diagnostics;
using kowabunga.Api;
using kowabunga.Client;
using kowabunga.Model;

namespace Example
{
    public class createAdapterExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new AdapterApi();
            var subnetId = subnetId_example;  // String | The ID of the network subnet. (default to null)
            var adapter = new Adapter(); // Adapter | 
            var assignIP = true;  // Boolean | Whether Kowabunga should pick and assign an IP address to this adapter. (optional)  (default to null)

            try {
                Adapter result = apiInstance.createAdapter(subnetId, adapter, assignIP);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdapterApi.createAdapter: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdapterApi();
$subnetId = subnetId_example; // String | The ID of the network subnet.
$adapter = ; // Adapter | 
$assignIP = true; // Boolean | Whether Kowabunga should pick and assign an IP address to this adapter.

try {
    $result = $api_instance->createAdapter($subnetId, $adapter, $assignIP);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AdapterApi->createAdapter: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AdapterApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdapterApi->new();
my $subnetId = subnetId_example; # String | The ID of the network subnet.
my $adapter = WWW::OPenAPIClient::Object::Adapter->new(); # Adapter | 
my $assignIP = true; # Boolean | Whether Kowabunga should pick and assign an IP address to this adapter.

eval {
    my $result = $api_instance->createAdapter(subnetId => $subnetId, adapter => $adapter, assignIP => $assignIP);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdapterApi->createAdapter: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.AdapterApi()
subnetId = subnetId_example # String | The ID of the network subnet. (default to null)
adapter =  # Adapter | 
assignIP = true # Boolean | Whether Kowabunga should pick and assign an IP address to this adapter. (optional) (default to null)

try:
    api_response = api_instance.create_adapter(subnetId, adapter, assignIP=assignIP)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdapterApi->createAdapter: %s\n" % e)

extern crate AdapterApi;

pub fn main() {
    let subnetId = subnetId_example; // String
    let adapter = ; // Adapter
    let assignIP = true; // Boolean

    let mut context = AdapterApi::Context::default();
    let result = client.createAdapter(subnetId, adapter, assignIP, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AdapterApi;

import java.io.File;
import java.util.*;

public class AdapterApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        AdapterApi apiInstance = new AdapterApi();
        String adapterId = adapterId_example; // String | The ID of the network adapter.

        try {
            apiInstance.deleteAdapter(adapterId);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdapterApi#deleteAdapter");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String adapterId = new String(); // String | The ID of the network adapter.

try {
    final result = await api_instance.deleteAdapter(adapterId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteAdapter: $e\n');
}

import org.openapitools.client.api.AdapterApi;

public class AdapterApiExample {
    public static void main(String[] args) {
        AdapterApi apiInstance = new AdapterApi();
        String adapterId = adapterId_example; // String | The ID of the network adapter.

        try {
            apiInstance.deleteAdapter(adapterId);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdapterApi#deleteAdapter");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
AdapterApi *apiInstance = [[AdapterApi alloc] init];
String *adapterId = adapterId_example; // The ID of the network adapter. (default to null)

[apiInstance deleteAdapterWith:adapterId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KowabungaApiDocumentation = require('kowabunga_api_documentation');
var defaultClient = KowabungaApiDocumentation.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new KowabungaApiDocumentation.AdapterApi()
var adapterId = adapterId_example; // {String} The ID of the network adapter.

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteAdapter(adapterId, callback);

using System;
using System.Diagnostics;
using kowabunga.Api;
using kowabunga.Client;
using kowabunga.Model;

namespace Example
{
    public class deleteAdapterExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new AdapterApi();
            var adapterId = adapterId_example;  // String | The ID of the network adapter. (default to null)

            try {
                apiInstance.deleteAdapter(adapterId);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdapterApi.deleteAdapter: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdapterApi();
$adapterId = adapterId_example; // String | The ID of the network adapter.

try {
    $api_instance->deleteAdapter($adapterId);
} catch (Exception $e) {
    echo 'Exception when calling AdapterApi->deleteAdapter: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AdapterApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdapterApi->new();
my $adapterId = adapterId_example; # String | The ID of the network adapter.

eval {
    $api_instance->deleteAdapter(adapterId => $adapterId);
};
if ($@) {
    warn "Exception when calling AdapterApi->deleteAdapter: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.AdapterApi()
adapterId = adapterId_example # String | The ID of the network adapter. (default to null)

try:
    api_instance.delete_adapter(adapterId)
except ApiException as e:
    print("Exception when calling AdapterApi->deleteAdapter: %s\n" % e)

extern crate AdapterApi;

pub fn main() {
    let adapterId = adapterId_example; // String

    let mut context = AdapterApi::Context::default();
    let result = client.deleteAdapter(adapterId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AdapterApi;

import java.io.File;
import java.util.*;

public class AdapterApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        AdapterApi apiInstance = new AdapterApi();

        try {
            array['String'] result = apiInstance.listAdapters();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdapterApi#listAdapters");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.listAdapters();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->listAdapters: $e\n');
}

import org.openapitools.client.api.AdapterApi;

public class AdapterApiExample {
    public static void main(String[] args) {
        AdapterApi apiInstance = new AdapterApi();

        try {
            array['String'] result = apiInstance.listAdapters();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdapterApi#listAdapters");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
AdapterApi *apiInstance = [[AdapterApi alloc] init];

[apiInstance listAdaptersWithCompletionHandler: 
              ^(array['String'] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KowabungaApiDocumentation = require('kowabunga_api_documentation');
var defaultClient = KowabungaApiDocumentation.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new KowabungaApiDocumentation.AdapterApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listAdapters(callback);

using System;
using System.Diagnostics;
using kowabunga.Api;
using kowabunga.Client;
using kowabunga.Model;

namespace Example
{
    public class listAdaptersExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new AdapterApi();

            try {
                array['String'] result = apiInstance.listAdapters();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdapterApi.listAdapters: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdapterApi();

try {
    $result = $api_instance->listAdapters();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AdapterApi->listAdapters: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AdapterApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdapterApi->new();

eval {
    my $result = $api_instance->listAdapters();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdapterApi->listAdapters: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.AdapterApi()

try:
    api_response = api_instance.list_adapters()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdapterApi->listAdapters: %s\n" % e)

extern crate AdapterApi;

pub fn main() {

    let mut context = AdapterApi::Context::default();
    let result = client.listAdapters(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AdapterApi;

import java.io.File;
import java.util.*;

public class AdapterApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        AdapterApi apiInstance = new AdapterApi();
        String subnetId = subnetId_example; // String | The ID of the network subnet.

        try {
            array['String'] result = apiInstance.listSubnetAdapters(subnetId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdapterApi#listSubnetAdapters");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String subnetId = new String(); // String | The ID of the network subnet.

try {
    final result = await api_instance.listSubnetAdapters(subnetId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->listSubnetAdapters: $e\n');
}

import org.openapitools.client.api.AdapterApi;

public class AdapterApiExample {
    public static void main(String[] args) {
        AdapterApi apiInstance = new AdapterApi();
        String subnetId = subnetId_example; // String | The ID of the network subnet.

        try {
            array['String'] result = apiInstance.listSubnetAdapters(subnetId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdapterApi#listSubnetAdapters");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
AdapterApi *apiInstance = [[AdapterApi alloc] init];
String *subnetId = subnetId_example; // The ID of the network subnet. (default to null)

[apiInstance listSubnetAdaptersWith:subnetId
              completionHandler: ^(array['String'] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KowabungaApiDocumentation = require('kowabunga_api_documentation');
var defaultClient = KowabungaApiDocumentation.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new KowabungaApiDocumentation.AdapterApi()
var subnetId = subnetId_example; // {String} The ID of the network subnet.

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listSubnetAdapters(subnetId, callback);

using System;
using System.Diagnostics;
using kowabunga.Api;
using kowabunga.Client;
using kowabunga.Model;

namespace Example
{
    public class listSubnetAdaptersExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new AdapterApi();
            var subnetId = subnetId_example;  // String | The ID of the network subnet. (default to null)

            try {
                array['String'] result = apiInstance.listSubnetAdapters(subnetId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdapterApi.listSubnetAdapters: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdapterApi();
$subnetId = subnetId_example; // String | The ID of the network subnet.

try {
    $result = $api_instance->listSubnetAdapters($subnetId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AdapterApi->listSubnetAdapters: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AdapterApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdapterApi->new();
my $subnetId = subnetId_example; # String | The ID of the network subnet.

eval {
    my $result = $api_instance->listSubnetAdapters(subnetId => $subnetId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdapterApi->listSubnetAdapters: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.AdapterApi()
subnetId = subnetId_example # String | The ID of the network subnet. (default to null)

try:
    api_response = api_instance.list_subnet_adapters(subnetId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdapterApi->listSubnetAdapters: %s\n" % e)

extern crate AdapterApi;

pub fn main() {
    let subnetId = subnetId_example; // String

    let mut context = AdapterApi::Context::default();
    let result = client.listSubnetAdapters(subnetId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AdapterApi;

import java.io.File;
import java.util.*;

public class AdapterApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        AdapterApi apiInstance = new AdapterApi();
        String adapterId = adapterId_example; // String | The ID of the network adapter.

        try {
            Adapter result = apiInstance.readAdapter(adapterId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdapterApi#readAdapter");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String adapterId = new String(); // String | The ID of the network adapter.

try {
    final result = await api_instance.readAdapter(adapterId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->readAdapter: $e\n');
}

import org.openapitools.client.api.AdapterApi;

public class AdapterApiExample {
    public static void main(String[] args) {
        AdapterApi apiInstance = new AdapterApi();
        String adapterId = adapterId_example; // String | The ID of the network adapter.

        try {
            Adapter result = apiInstance.readAdapter(adapterId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdapterApi#readAdapter");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
AdapterApi *apiInstance = [[AdapterApi alloc] init];
String *adapterId = adapterId_example; // The ID of the network adapter. (default to null)

[apiInstance readAdapterWith:adapterId
              completionHandler: ^(Adapter output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KowabungaApiDocumentation = require('kowabunga_api_documentation');
var defaultClient = KowabungaApiDocumentation.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new KowabungaApiDocumentation.AdapterApi()
var adapterId = adapterId_example; // {String} The ID of the network adapter.

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.readAdapter(adapterId, callback);

using System;
using System.Diagnostics;
using kowabunga.Api;
using kowabunga.Client;
using kowabunga.Model;

namespace Example
{
    public class readAdapterExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new AdapterApi();
            var adapterId = adapterId_example;  // String | The ID of the network adapter. (default to null)

            try {
                Adapter result = apiInstance.readAdapter(adapterId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdapterApi.readAdapter: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdapterApi();
$adapterId = adapterId_example; // String | The ID of the network adapter.

try {
    $result = $api_instance->readAdapter($adapterId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AdapterApi->readAdapter: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AdapterApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdapterApi->new();
my $adapterId = adapterId_example; # String | The ID of the network adapter.

eval {
    my $result = $api_instance->readAdapter(adapterId => $adapterId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdapterApi->readAdapter: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.AdapterApi()
adapterId = adapterId_example # String | The ID of the network adapter. (default to null)

try:
    api_response = api_instance.read_adapter(adapterId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdapterApi->readAdapter: %s\n" % e)

extern crate AdapterApi;

pub fn main() {
    let adapterId = adapterId_example; // String

    let mut context = AdapterApi::Context::default();
    let result = client.readAdapter(adapterId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AdapterApi;

import java.io.File;
import java.util.*;

public class AdapterApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        AdapterApi apiInstance = new AdapterApi();
        String adapterId = adapterId_example; // String | The ID of the network adapter.
        Adapter adapter = ; // Adapter | 

        try {
            Adapter result = apiInstance.updateAdapter(adapterId, adapter);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdapterApi#updateAdapter");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String adapterId = new String(); // String | The ID of the network adapter.
final Adapter adapter = new Adapter(); // Adapter | 

try {
    final result = await api_instance.updateAdapter(adapterId, adapter);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->updateAdapter: $e\n');
}

import org.openapitools.client.api.AdapterApi;

public class AdapterApiExample {
    public static void main(String[] args) {
        AdapterApi apiInstance = new AdapterApi();
        String adapterId = adapterId_example; // String | The ID of the network adapter.
        Adapter adapter = ; // Adapter | 

        try {
            Adapter result = apiInstance.updateAdapter(adapterId, adapter);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdapterApi#updateAdapter");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
AdapterApi *apiInstance = [[AdapterApi alloc] init];
String *adapterId = adapterId_example; // The ID of the network adapter. (default to null)
Adapter *adapter = ; // 

[apiInstance updateAdapterWith:adapterId
    adapter:adapter
              completionHandler: ^(Adapter output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KowabungaApiDocumentation = require('kowabunga_api_documentation');
var defaultClient = KowabungaApiDocumentation.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new KowabungaApiDocumentation.AdapterApi()
var adapterId = adapterId_example; // {String} The ID of the network adapter.
var adapter = ; // {Adapter} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateAdapter(adapterId, adapter, callback);

using System;
using System.Diagnostics;
using kowabunga.Api;
using kowabunga.Client;
using kowabunga.Model;

namespace Example
{
    public class updateAdapterExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new AdapterApi();
            var adapterId = adapterId_example;  // String | The ID of the network adapter. (default to null)
            var adapter = new Adapter(); // Adapter | 

            try {
                Adapter result = apiInstance.updateAdapter(adapterId, adapter);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdapterApi.updateAdapter: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdapterApi();
$adapterId = adapterId_example; // String | The ID of the network adapter.
$adapter = ; // Adapter | 

try {
    $result = $api_instance->updateAdapter($adapterId, $adapter);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AdapterApi->updateAdapter: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AdapterApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdapterApi->new();
my $adapterId = adapterId_example; # String | The ID of the network adapter.
my $adapter = WWW::OPenAPIClient::Object::Adapter->new(); # Adapter | 

eval {
    my $result = $api_instance->updateAdapter(adapterId => $adapterId, adapter => $adapter);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdapterApi->updateAdapter: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.AdapterApi()
adapterId = adapterId_example # String | The ID of the network adapter. (default to null)
adapter =  # Adapter | 

try:
    api_response = api_instance.update_adapter(adapterId, adapter)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdapterApi->updateAdapter: %s\n" % e)

extern crate AdapterApi;

pub fn main() {
    let adapterId = adapterId_example; // String
    let adapter = ; // Adapter

    let mut context = AdapterApi::Context::default();
    let result = client.updateAdapter(adapterId, adapter, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AgentApi;

import java.io.File;
import java.util.*;

public class AgentApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        AgentApi apiInstance = new AgentApi();
        Agent agent = ; // Agent | 

        try {
            Agent result = apiInstance.createAgent(agent);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentApi#createAgent");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Agent agent = new Agent(); // Agent | 

try {
    final result = await api_instance.createAgent(agent);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->createAgent: $e\n');
}

import org.openapitools.client.api.AgentApi;

public class AgentApiExample {
    public static void main(String[] args) {
        AgentApi apiInstance = new AgentApi();
        Agent agent = ; // Agent | 

        try {
            Agent result = apiInstance.createAgent(agent);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentApi#createAgent");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
AgentApi *apiInstance = [[AgentApi alloc] init];
Agent *agent = ; // 

[apiInstance createAgentWith:agent
              completionHandler: ^(Agent output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KowabungaApiDocumentation = require('kowabunga_api_documentation');
var defaultClient = KowabungaApiDocumentation.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new KowabungaApiDocumentation.AgentApi()
var agent = ; // {Agent} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createAgent(agent, callback);

using System;
using System.Diagnostics;
using kowabunga.Api;
using kowabunga.Client;
using kowabunga.Model;

namespace Example
{
    public class createAgentExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new AgentApi();
            var agent = new Agent(); // Agent | 

            try {
                Agent result = apiInstance.createAgent(agent);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AgentApi.createAgent: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AgentApi();
$agent = ; // Agent | 

try {
    $result = $api_instance->createAgent($agent);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AgentApi->createAgent: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AgentApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AgentApi->new();
my $agent = WWW::OPenAPIClient::Object::Agent->new(); # Agent | 

eval {
    my $result = $api_instance->createAgent(agent => $agent);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AgentApi->createAgent: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.AgentApi()
agent =  # Agent | 

try:
    api_response = api_instance.create_agent(agent)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentApi->createAgent: %s\n" % e)

extern crate AgentApi;

pub fn main() {
    let agent = ; // Agent

    let mut context = AgentApi::Context::default();
    let result = client.createAgent(agent, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AgentApi;

import java.io.File;
import java.util.*;

public class AgentApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        AgentApi apiInstance = new AgentApi();
        String agentId = agentId_example; // String | The ID of the Kowabunga remote agent.

        try {
            apiInstance.deleteAgent(agentId);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentApi#deleteAgent");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String agentId = new String(); // String | The ID of the Kowabunga remote agent.

try {
    final result = await api_instance.deleteAgent(agentId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteAgent: $e\n');
}

import org.openapitools.client.api.AgentApi;

public class AgentApiExample {
    public static void main(String[] args) {
        AgentApi apiInstance = new AgentApi();
        String agentId = agentId_example; // String | The ID of the Kowabunga remote agent.

        try {
            apiInstance.deleteAgent(agentId);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentApi#deleteAgent");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
AgentApi *apiInstance = [[AgentApi alloc] init];
String *agentId = agentId_example; // The ID of the Kowabunga remote agent. (default to null)

[apiInstance deleteAgentWith:agentId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KowabungaApiDocumentation = require('kowabunga_api_documentation');
var defaultClient = KowabungaApiDocumentation.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new KowabungaApiDocumentation.AgentApi()
var agentId = agentId_example; // {String} The ID of the Kowabunga remote agent.

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteAgent(agentId, callback);

using System;
using System.Diagnostics;
using kowabunga.Api;
using kowabunga.Client;
using kowabunga.Model;

namespace Example
{
    public class deleteAgentExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new AgentApi();
            var agentId = agentId_example;  // String | The ID of the Kowabunga remote agent. (default to null)

            try {
                apiInstance.deleteAgent(agentId);
            } catch (Exception e) {
                Debug.Print("Exception when calling AgentApi.deleteAgent: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AgentApi();
$agentId = agentId_example; // String | The ID of the Kowabunga remote agent.

try {
    $api_instance->deleteAgent($agentId);
} catch (Exception $e) {
    echo 'Exception when calling AgentApi->deleteAgent: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AgentApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AgentApi->new();
my $agentId = agentId_example; # String | The ID of the Kowabunga remote agent.

eval {
    $api_instance->deleteAgent(agentId => $agentId);
};
if ($@) {
    warn "Exception when calling AgentApi->deleteAgent: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.AgentApi()
agentId = agentId_example # String | The ID of the Kowabunga remote agent. (default to null)

try:
    api_instance.delete_agent(agentId)
except ApiException as e:
    print("Exception when calling AgentApi->deleteAgent: %s\n" % e)

extern crate AgentApi;

pub fn main() {
    let agentId = agentId_example; // String

    let mut context = AgentApi::Context::default();
    let result = client.deleteAgent(agentId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AgentApi;

import java.io.File;
import java.util.*;

public class AgentApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        AgentApi apiInstance = new AgentApi();

        try {
            array['String'] result = apiInstance.listAgents();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentApi#listAgents");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.listAgents();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->listAgents: $e\n');
}

import org.openapitools.client.api.AgentApi;

public class AgentApiExample {
    public static void main(String[] args) {
        AgentApi apiInstance = new AgentApi();

        try {
            array['String'] result = apiInstance.listAgents();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentApi#listAgents");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
AgentApi *apiInstance = [[AgentApi alloc] init];

[apiInstance listAgentsWithCompletionHandler: 
              ^(array['String'] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KowabungaApiDocumentation = require('kowabunga_api_documentation');
var defaultClient = KowabungaApiDocumentation.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new KowabungaApiDocumentation.AgentApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listAgents(callback);

using System;
using System.Diagnostics;
using kowabunga.Api;
using kowabunga.Client;
using kowabunga.Model;

namespace Example
{
    public class listAgentsExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new AgentApi();

            try {
                array['String'] result = apiInstance.listAgents();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AgentApi.listAgents: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AgentApi();

try {
    $result = $api_instance->listAgents();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AgentApi->listAgents: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AgentApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AgentApi->new();

eval {
    my $result = $api_instance->listAgents();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AgentApi->listAgents: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.AgentApi()

try:
    api_response = api_instance.list_agents()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentApi->listAgents: %s\n" % e)

extern crate AgentApi;

pub fn main() {

    let mut context = AgentApi::Context::default();
    let result = client.listAgents(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AgentApi;

import java.io.File;
import java.util.*;

public class AgentApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        AgentApi apiInstance = new AgentApi();
        String agentId = agentId_example; // String | The ID of the Kowabunga remote agent.

        try {
            Agent result = apiInstance.readAgent(agentId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentApi#readAgent");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String agentId = new String(); // String | The ID of the Kowabunga remote agent.

try {
    final result = await api_instance.readAgent(agentId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->readAgent: $e\n');
}

import org.openapitools.client.api.AgentApi;

public class AgentApiExample {
    public static void main(String[] args) {
        AgentApi apiInstance = new AgentApi();
        String agentId = agentId_example; // String | The ID of the Kowabunga remote agent.

        try {
            Agent result = apiInstance.readAgent(agentId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentApi#readAgent");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
AgentApi *apiInstance = [[AgentApi alloc] init];
String *agentId = agentId_example; // The ID of the Kowabunga remote agent. (default to null)

[apiInstance readAgentWith:agentId
              completionHandler: ^(Agent output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KowabungaApiDocumentation = require('kowabunga_api_documentation');
var defaultClient = KowabungaApiDocumentation.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new KowabungaApiDocumentation.AgentApi()
var agentId = agentId_example; // {String} The ID of the Kowabunga remote agent.

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.readAgent(agentId, callback);

using System;
using System.Diagnostics;
using kowabunga.Api;
using kowabunga.Client;
using kowabunga.Model;

namespace Example
{
    public class readAgentExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new AgentApi();
            var agentId = agentId_example;  // String | The ID of the Kowabunga remote agent. (default to null)

            try {
                Agent result = apiInstance.readAgent(agentId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AgentApi.readAgent: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AgentApi();
$agentId = agentId_example; // String | The ID of the Kowabunga remote agent.

try {
    $result = $api_instance->readAgent($agentId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AgentApi->readAgent: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AgentApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AgentApi->new();
my $agentId = agentId_example; # String | The ID of the Kowabunga remote agent.

eval {
    my $result = $api_instance->readAgent(agentId => $agentId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AgentApi->readAgent: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.AgentApi()
agentId = agentId_example # String | The ID of the Kowabunga remote agent. (default to null)

try:
    api_response = api_instance.read_agent(agentId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentApi->readAgent: %s\n" % e)

extern crate AgentApi;

pub fn main() {
    let agentId = agentId_example; // String

    let mut context = AgentApi::Context::default();
    let result = client.readAgent(agentId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AgentApi;

import java.io.File;
import java.util.*;

public class AgentApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        AgentApi apiInstance = new AgentApi();
        String agentId = agentId_example; // String | The ID of the Kowabunga remote agent.
        Boolean expire = true; // Boolean | Whether or not the token should expire.
        date expirationDate = 2013-10-20; // date | Token's expiration date (YYYY-MM-DD format).

        try {
            ApiToken result = apiInstance.setAgentApiToken(agentId, expire, expirationDate);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentApi#setAgentApiToken");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String agentId = new String(); // String | The ID of the Kowabunga remote agent.
final Boolean expire = new Boolean(); // Boolean | Whether or not the token should expire.
final date expirationDate = new date(); // date | Token's expiration date (YYYY-MM-DD format).

try {
    final result = await api_instance.setAgentApiToken(agentId, expire, expirationDate);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->setAgentApiToken: $e\n');
}

import org.openapitools.client.api.AgentApi;

public class AgentApiExample {
    public static void main(String[] args) {
        AgentApi apiInstance = new AgentApi();
        String agentId = agentId_example; // String | The ID of the Kowabunga remote agent.
        Boolean expire = true; // Boolean | Whether or not the token should expire.
        date expirationDate = 2013-10-20; // date | Token's expiration date (YYYY-MM-DD format).

        try {
            ApiToken result = apiInstance.setAgentApiToken(agentId, expire, expirationDate);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentApi#setAgentApiToken");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
AgentApi *apiInstance = [[AgentApi alloc] init];
String *agentId = agentId_example; // The ID of the Kowabunga remote agent. (default to null)
Boolean *expire = true; // Whether or not the token should expire. (optional) (default to null)
date *expirationDate = 2013-10-20; // Token's expiration date (YYYY-MM-DD format). (optional) (default to null)

[apiInstance setAgentApiTokenWith:agentId
    expire:expire
    expirationDate:expirationDate
              completionHandler: ^(ApiToken output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KowabungaApiDocumentation = require('kowabunga_api_documentation');
var defaultClient = KowabungaApiDocumentation.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new KowabungaApiDocumentation.AgentApi()
var agentId = agentId_example; // {String} The ID of the Kowabunga remote agent.
var opts = {
  'expire': true, // {Boolean} Whether or not the token should expire.
  'expirationDate': 2013-10-20 // {date} Token's expiration date (YYYY-MM-DD format).
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.setAgentApiToken(agentId, opts, callback);

using System;
using System.Diagnostics;
using kowabunga.Api;
using kowabunga.Client;
using kowabunga.Model;

namespace Example
{
    public class setAgentApiTokenExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new AgentApi();
            var agentId = agentId_example;  // String | The ID of the Kowabunga remote agent. (default to null)
            var expire = true;  // Boolean | Whether or not the token should expire. (optional)  (default to null)
            var expirationDate = 2013-10-20;  // date | Token's expiration date (YYYY-MM-DD format). (optional)  (default to null)

            try {
                ApiToken result = apiInstance.setAgentApiToken(agentId, expire, expirationDate);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AgentApi.setAgentApiToken: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AgentApi();
$agentId = agentId_example; // String | The ID of the Kowabunga remote agent.
$expire = true; // Boolean | Whether or not the token should expire.
$expirationDate = 2013-10-20; // date | Token's expiration date (YYYY-MM-DD format).

try {
    $result = $api_instance->setAgentApiToken($agentId, $expire, $expirationDate);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AgentApi->setAgentApiToken: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AgentApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AgentApi->new();
my $agentId = agentId_example; # String | The ID of the Kowabunga remote agent.
my $expire = true; # Boolean | Whether or not the token should expire.
my $expirationDate = 2013-10-20; # date | Token's expiration date (YYYY-MM-DD format).

eval {
    my $result = $api_instance->setAgentApiToken(agentId => $agentId, expire => $expire, expirationDate => $expirationDate);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AgentApi->setAgentApiToken: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.AgentApi()
agentId = agentId_example # String | The ID of the Kowabunga remote agent. (default to null)
expire = true # Boolean | Whether or not the token should expire. (optional) (default to null)
expirationDate = 2013-10-20 # date | Token's expiration date (YYYY-MM-DD format). (optional) (default to null)

try:
    api_response = api_instance.set_agent_api_token(agentId, expire=expire, expirationDate=expirationDate)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentApi->setAgentApiToken: %s\n" % e)

extern crate AgentApi;

pub fn main() {
    let agentId = agentId_example; // String
    let expire = true; // Boolean
    let expirationDate = 2013-10-20; // date

    let mut context = AgentApi::Context::default();
    let result = client.setAgentApiToken(agentId, expire, expirationDate, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AgentApi;

import java.io.File;
import java.util.*;

public class AgentApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        AgentApi apiInstance = new AgentApi();
        String agentId = agentId_example; // String | The ID of the Kowabunga remote agent.
        Agent agent = ; // Agent | 

        try {
            Agent result = apiInstance.updateAgent(agentId, agent);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentApi#updateAgent");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String agentId = new String(); // String | The ID of the Kowabunga remote agent.
final Agent agent = new Agent(); // Agent | 

try {
    final result = await api_instance.updateAgent(agentId, agent);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->updateAgent: $e\n');
}

import org.openapitools.client.api.AgentApi;

public class AgentApiExample {
    public static void main(String[] args) {
        AgentApi apiInstance = new AgentApi();
        String agentId = agentId_example; // String | The ID of the Kowabunga remote agent.
        Agent agent = ; // Agent | 

        try {
            Agent result = apiInstance.updateAgent(agentId, agent);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentApi#updateAgent");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
AgentApi *apiInstance = [[AgentApi alloc] init];
String *agentId = agentId_example; // The ID of the Kowabunga remote agent. (default to null)
Agent *agent = ; // 

[apiInstance updateAgentWith:agentId
    agent:agent
              completionHandler: ^(Agent output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KowabungaApiDocumentation = require('kowabunga_api_documentation');
var defaultClient = KowabungaApiDocumentation.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new KowabungaApiDocumentation.AgentApi()
var agentId = agentId_example; // {String} The ID of the Kowabunga remote agent.
var agent = ; // {Agent} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateAgent(agentId, agent, callback);

using System;
using System.Diagnostics;
using kowabunga.Api;
using kowabunga.Client;
using kowabunga.Model;

namespace Example
{
    public class updateAgentExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new AgentApi();
            var agentId = agentId_example;  // String | The ID of the Kowabunga remote agent. (default to null)
            var agent = new Agent(); // Agent | 

            try {
                Agent result = apiInstance.updateAgent(agentId, agent);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AgentApi.updateAgent: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AgentApi();
$agentId = agentId_example; // String | The ID of the Kowabunga remote agent.
$agent = ; // Agent | 

try {
    $result = $api_instance->updateAgent($agentId, $agent);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AgentApi->updateAgent: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AgentApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AgentApi->new();
my $agentId = agentId_example; # String | The ID of the Kowabunga remote agent.
my $agent = WWW::OPenAPIClient::Object::Agent->new(); # Agent | 

eval {
    my $result = $api_instance->updateAgent(agentId => $agentId, agent => $agent);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AgentApi->updateAgent: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.AgentApi()
agentId = agentId_example # String | The ID of the Kowabunga remote agent. (default to null)
agent =  # Agent | 

try:
    api_response = api_instance.update_agent(agentId, agent)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentApi->updateAgent: %s\n" % e)

extern crate AgentApi;

pub fn main() {
    let agentId = agentId_example; // String
    let agent = ; // Agent

    let mut context = AgentApi::Context::default();
    let result = client.updateAgent(agentId, agent, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.InstanceApi;

import java.io.File;
import java.util.*;

public class InstanceApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        InstanceApi apiInstance = new InstanceApi();
        String projectId = projectId_example; // String | The ID of the project.
        String zoneId = zoneId_example; // String | The ID of the availability zone.
        Instance instance = ; // Instance | 

        try {
            Instance result = apiInstance.createProjectZoneInstance(projectId, zoneId, instance);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling InstanceApi#createProjectZoneInstance");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String projectId = new String(); // String | The ID of the project.
final String zoneId = new String(); // String | The ID of the availability zone.
final Instance instance = new Instance(); // Instance | 

try {
    final result = await api_instance.createProjectZoneInstance(projectId, zoneId, instance);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->createProjectZoneInstance: $e\n');
}

import org.openapitools.client.api.InstanceApi;

public class InstanceApiExample {
    public static void main(String[] args) {
        InstanceApi apiInstance = new InstanceApi();
        String projectId = projectId_example; // String | The ID of the project.
        String zoneId = zoneId_example; // String | The ID of the availability zone.
        Instance instance = ; // Instance | 

        try {
            Instance result = apiInstance.createProjectZoneInstance(projectId, zoneId, instance);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling InstanceApi#createProjectZoneInstance");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
InstanceApi *apiInstance = [[InstanceApi alloc] init];
String *projectId = projectId_example; // The ID of the project. (default to null)
String *zoneId = zoneId_example; // The ID of the availability zone. (default to null)
Instance *instance = ; // 

[apiInstance createProjectZoneInstanceWith:projectId
    zoneId:zoneId
    instance:instance
              completionHandler: ^(Instance output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KowabungaApiDocumentation = require('kowabunga_api_documentation');
var defaultClient = KowabungaApiDocumentation.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new KowabungaApiDocumentation.InstanceApi()
var projectId = projectId_example; // {String} The ID of the project.
var zoneId = zoneId_example; // {String} The ID of the availability zone.
var instance = ; // {Instance} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createProjectZoneInstance(projectId, zoneId, instance, callback);

using System;
using System.Diagnostics;
using kowabunga.Api;
using kowabunga.Client;
using kowabunga.Model;

namespace Example
{
    public class createProjectZoneInstanceExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new InstanceApi();
            var projectId = projectId_example;  // String | The ID of the project. (default to null)
            var zoneId = zoneId_example;  // String | The ID of the availability zone. (default to null)
            var instance = new Instance(); // Instance | 

            try {
                Instance result = apiInstance.createProjectZoneInstance(projectId, zoneId, instance);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling InstanceApi.createProjectZoneInstance: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\InstanceApi();
$projectId = projectId_example; // String | The ID of the project.
$zoneId = zoneId_example; // String | The ID of the availability zone.
$instance = ; // Instance | 

try {
    $result = $api_instance->createProjectZoneInstance($projectId, $zoneId, $instance);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling InstanceApi->createProjectZoneInstance: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::InstanceApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::InstanceApi->new();
my $projectId = projectId_example; # String | The ID of the project.
my $zoneId = zoneId_example; # String | The ID of the availability zone.
my $instance = WWW::OPenAPIClient::Object::Instance->new(); # Instance | 

eval {
    my $result = $api_instance->createProjectZoneInstance(projectId => $projectId, zoneId => $zoneId, instance => $instance);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling InstanceApi->createProjectZoneInstance: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.InstanceApi()
projectId = projectId_example # String | The ID of the project. (default to null)
zoneId = zoneId_example # String | The ID of the availability zone. (default to null)
instance =  # Instance | 

try:
    api_response = api_instance.create_project_zone_instance(projectId, zoneId, instance)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling InstanceApi->createProjectZoneInstance: %s\n" % e)

extern crate InstanceApi;

pub fn main() {
    let projectId = projectId_example; // String
    let zoneId = zoneId_example; // String
    let instance = ; // Instance

    let mut context = InstanceApi::Context::default();
    let result = client.createProjectZoneInstance(projectId, zoneId, instance, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.InstanceApi;

import java.io.File;
import java.util.*;

public class InstanceApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        InstanceApi apiInstance = new InstanceApi();
        String instanceId = instanceId_example; // String | The ID of the virtual machine instance.

        try {
            apiInstance.deleteInstance(instanceId);
        } catch (ApiException e) {
            System.err.println("Exception when calling InstanceApi#deleteInstance");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String instanceId = new String(); // String | The ID of the virtual machine instance.

try {
    final result = await api_instance.deleteInstance(instanceId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteInstance: $e\n');
}

import org.openapitools.client.api.InstanceApi;

public class InstanceApiExample {
    public static void main(String[] args) {
        InstanceApi apiInstance = new InstanceApi();
        String instanceId = instanceId_example; // String | The ID of the virtual machine instance.

        try {
            apiInstance.deleteInstance(instanceId);
        } catch (ApiException e) {
            System.err.println("Exception when calling InstanceApi#deleteInstance");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
InstanceApi *apiInstance = [[InstanceApi alloc] init];
String *instanceId = instanceId_example; // The ID of the virtual machine instance. (default to null)

[apiInstance deleteInstanceWith:instanceId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KowabungaApiDocumentation = require('kowabunga_api_documentation');
var defaultClient = KowabungaApiDocumentation.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new KowabungaApiDocumentation.InstanceApi()
var instanceId = instanceId_example; // {String} The ID of the virtual machine instance.

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteInstance(instanceId, callback);

using System;
using System.Diagnostics;
using kowabunga.Api;
using kowabunga.Client;
using kowabunga.Model;

namespace Example
{
    public class deleteInstanceExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new InstanceApi();
            var instanceId = instanceId_example;  // String | The ID of the virtual machine instance. (default to null)

            try {
                apiInstance.deleteInstance(instanceId);
            } catch (Exception e) {
                Debug.Print("Exception when calling InstanceApi.deleteInstance: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\InstanceApi();
$instanceId = instanceId_example; // String | The ID of the virtual machine instance.

try {
    $api_instance->deleteInstance($instanceId);
} catch (Exception $e) {
    echo 'Exception when calling InstanceApi->deleteInstance: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::InstanceApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::InstanceApi->new();
my $instanceId = instanceId_example; # String | The ID of the virtual machine instance.

eval {
    $api_instance->deleteInstance(instanceId => $instanceId);
};
if ($@) {
    warn "Exception when calling InstanceApi->deleteInstance: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.InstanceApi()
instanceId = instanceId_example # String | The ID of the virtual machine instance. (default to null)

try:
    api_instance.delete_instance(instanceId)
except ApiException as e:
    print("Exception when calling InstanceApi->deleteInstance: %s\n" % e)

extern crate InstanceApi;

pub fn main() {
    let instanceId = instanceId_example; // String

    let mut context = InstanceApi::Context::default();
    let result = client.deleteInstance(instanceId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.InstanceApi;

import java.io.File;
import java.util.*;

public class InstanceApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        InstanceApi apiInstance = new InstanceApi();

        try {
            array['String'] result = apiInstance.listInstances();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling InstanceApi#listInstances");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.listInstances();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->listInstances: $e\n');
}

import org.openapitools.client.api.InstanceApi;

public class InstanceApiExample {
    public static void main(String[] args) {
        InstanceApi apiInstance = new InstanceApi();

        try {
            array['String'] result = apiInstance.listInstances();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling InstanceApi#listInstances");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
InstanceApi *apiInstance = [[InstanceApi alloc] init];

[apiInstance listInstancesWithCompletionHandler: 
              ^(array['String'] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KowabungaApiDocumentation = require('kowabunga_api_documentation');
var defaultClient = KowabungaApiDocumentation.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new KowabungaApiDocumentation.InstanceApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listInstances(callback);

using System;
using System.Diagnostics;
using kowabunga.Api;
using kowabunga.Client;
using kowabunga.Model;

namespace Example
{
    public class listInstancesExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new InstanceApi();

            try {
                array['String'] result = apiInstance.listInstances();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling InstanceApi.listInstances: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\InstanceApi();

try {
    $result = $api_instance->listInstances();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling InstanceApi->listInstances: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::InstanceApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::InstanceApi->new();

eval {
    my $result = $api_instance->listInstances();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling InstanceApi->listInstances: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.InstanceApi()

try:
    api_response = api_instance.list_instances()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling InstanceApi->listInstances: %s\n" % e)

extern crate InstanceApi;

pub fn main() {

    let mut context = InstanceApi::Context::default();
    let result = client.listInstances(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.InstanceApi;

import java.io.File;
import java.util.*;

public class InstanceApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        InstanceApi apiInstance = new InstanceApi();
        String kaktusId = kaktusId_example; // String | The ID of the Kaktus computing node.

        try {
            array['String'] result = apiInstance.listKaktusInstances(kaktusId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling InstanceApi#listKaktusInstances");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String kaktusId = new String(); // String | The ID of the Kaktus computing node.

try {
    final result = await api_instance.listKaktusInstances(kaktusId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->listKaktusInstances: $e\n');
}

import org.openapitools.client.api.InstanceApi;

public class InstanceApiExample {
    public static void main(String[] args) {
        InstanceApi apiInstance = new InstanceApi();
        String kaktusId = kaktusId_example; // String | The ID of the Kaktus computing node.

        try {
            array['String'] result = apiInstance.listKaktusInstances(kaktusId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling InstanceApi#listKaktusInstances");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
InstanceApi *apiInstance = [[InstanceApi alloc] init];
String *kaktusId = kaktusId_example; // The ID of the Kaktus computing node. (default to null)

[apiInstance listKaktusInstancesWith:kaktusId
              completionHandler: ^(array['String'] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KowabungaApiDocumentation = require('kowabunga_api_documentation');
var defaultClient = KowabungaApiDocumentation.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new KowabungaApiDocumentation.InstanceApi()
var kaktusId = kaktusId_example; // {String} The ID of the Kaktus computing node.

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listKaktusInstances(kaktusId, callback);

using System;
using System.Diagnostics;
using kowabunga.Api;
using kowabunga.Client;
using kowabunga.Model;

namespace Example
{
    public class listKaktusInstancesExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new InstanceApi();
            var kaktusId = kaktusId_example;  // String | The ID of the Kaktus computing node. (default to null)

            try {
                array['String'] result = apiInstance.listKaktusInstances(kaktusId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling InstanceApi.listKaktusInstances: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\InstanceApi();
$kaktusId = kaktusId_example; // String | The ID of the Kaktus computing node.

try {
    $result = $api_instance->listKaktusInstances($kaktusId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling InstanceApi->listKaktusInstances: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::InstanceApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::InstanceApi->new();
my $kaktusId = kaktusId_example; # String | The ID of the Kaktus computing node.

eval {
    my $result = $api_instance->listKaktusInstances(kaktusId => $kaktusId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling InstanceApi->listKaktusInstances: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.InstanceApi()
kaktusId = kaktusId_example # String | The ID of the Kaktus computing node. (default to null)

try:
    api_response = api_instance.list_kaktus_instances(kaktusId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling InstanceApi->listKaktusInstances: %s\n" % e)

extern crate InstanceApi;

pub fn main() {
    let kaktusId = kaktusId_example; // String

    let mut context = InstanceApi::Context::default();
    let result = client.listKaktusInstances(kaktusId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.InstanceApi;

import java.io.File;
import java.util.*;

public class InstanceApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        InstanceApi apiInstance = new InstanceApi();
        String projectId = projectId_example; // String | The ID of the project.
        String zoneId = zoneId_example; // String | The ID of the availability zone.

        try {
            array['String'] result = apiInstance.listProjectZoneInstances(projectId, zoneId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling InstanceApi#listProjectZoneInstances");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String projectId = new String(); // String | The ID of the project.
final String zoneId = new String(); // String | The ID of the availability zone.

try {
    final result = await api_instance.listProjectZoneInstances(projectId, zoneId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->listProjectZoneInstances: $e\n');
}

import org.openapitools.client.api.InstanceApi;

public class InstanceApiExample {
    public static void main(String[] args) {
        InstanceApi apiInstance = new InstanceApi();
        String projectId = projectId_example; // String | The ID of the project.
        String zoneId = zoneId_example; // String | The ID of the availability zone.

        try {
            array['String'] result = apiInstance.listProjectZoneInstances(projectId, zoneId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling InstanceApi#listProjectZoneInstances");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
InstanceApi *apiInstance = [[InstanceApi alloc] init];
String *projectId = projectId_example; // The ID of the project. (default to null)
String *zoneId = zoneId_example; // The ID of the availability zone. (default to null)

[apiInstance listProjectZoneInstancesWith:projectId
    zoneId:zoneId
              completionHandler: ^(array['String'] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KowabungaApiDocumentation = require('kowabunga_api_documentation');
var defaultClient = KowabungaApiDocumentation.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new KowabungaApiDocumentation.InstanceApi()
var projectId = projectId_example; // {String} The ID of the project.
var zoneId = zoneId_example; // {String} The ID of the availability zone.

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listProjectZoneInstances(projectId, zoneId, callback);

using System;
using System.Diagnostics;
using kowabunga.Api;
using kowabunga.Client;
using kowabunga.Model;

namespace Example
{
    public class listProjectZoneInstancesExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new InstanceApi();
            var projectId = projectId_example;  // String | The ID of the project. (default to null)
            var zoneId = zoneId_example;  // String | The ID of the availability zone. (default to null)

            try {
                array['String'] result = apiInstance.listProjectZoneInstances(projectId, zoneId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling InstanceApi.listProjectZoneInstances: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\InstanceApi();
$projectId = projectId_example; // String | The ID of the project.
$zoneId = zoneId_example; // String | The ID of the availability zone.

try {
    $result = $api_instance->listProjectZoneInstances($projectId, $zoneId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling InstanceApi->listProjectZoneInstances: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::InstanceApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::InstanceApi->new();
my $projectId = projectId_example; # String | The ID of the project.
my $zoneId = zoneId_example; # String | The ID of the availability zone.

eval {
    my $result = $api_instance->listProjectZoneInstances(projectId => $projectId, zoneId => $zoneId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling InstanceApi->listProjectZoneInstances: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.InstanceApi()
projectId = projectId_example # String | The ID of the project. (default to null)
zoneId = zoneId_example # String | The ID of the availability zone. (default to null)

try:
    api_response = api_instance.list_project_zone_instances(projectId, zoneId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling InstanceApi->listProjectZoneInstances: %s\n" % e)

extern crate InstanceApi;

pub fn main() {
    let projectId = projectId_example; // String
    let zoneId = zoneId_example; // String

    let mut context = InstanceApi::Context::default();
    let result = client.listProjectZoneInstances(projectId, zoneId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.InstanceApi;

import java.io.File;
import java.util.*;

public class InstanceApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        InstanceApi apiInstance = new InstanceApi();
        String instanceId = instanceId_example; // String | The ID of the virtual machine instance.

        try {
            Instance result = apiInstance.readInstance(instanceId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling InstanceApi#readInstance");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String instanceId = new String(); // String | The ID of the virtual machine instance.

try {
    final result = await api_instance.readInstance(instanceId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->readInstance: $e\n');
}

import org.openapitools.client.api.InstanceApi;

public class InstanceApiExample {
    public static void main(String[] args) {
        InstanceApi apiInstance = new InstanceApi();
        String instanceId = instanceId_example; // String | The ID of the virtual machine instance.

        try {
            Instance result = apiInstance.readInstance(instanceId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling InstanceApi#readInstance");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
InstanceApi *apiInstance = [[InstanceApi alloc] init];
String *instanceId = instanceId_example; // The ID of the virtual machine instance. (default to null)

[apiInstance readInstanceWith:instanceId
              completionHandler: ^(Instance output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KowabungaApiDocumentation = require('kowabunga_api_documentation');
var defaultClient = KowabungaApiDocumentation.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new KowabungaApiDocumentation.InstanceApi()
var instanceId = instanceId_example; // {String} The ID of the virtual machine instance.

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.readInstance(instanceId, callback);

using System;
using System.Diagnostics;
using kowabunga.Api;
using kowabunga.Client;
using kowabunga.Model;

namespace Example
{
    public class readInstanceExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new InstanceApi();
            var instanceId = instanceId_example;  // String | The ID of the virtual machine instance. (default to null)

            try {
                Instance result = apiInstance.readInstance(instanceId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling InstanceApi.readInstance: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\InstanceApi();
$instanceId = instanceId_example; // String | The ID of the virtual machine instance.

try {
    $result = $api_instance->readInstance($instanceId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling InstanceApi->readInstance: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::InstanceApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::InstanceApi->new();
my $instanceId = instanceId_example; # String | The ID of the virtual machine instance.

eval {
    my $result = $api_instance->readInstance(instanceId => $instanceId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling InstanceApi->readInstance: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.InstanceApi()
instanceId = instanceId_example # String | The ID of the virtual machine instance. (default to null)

try:
    api_response = api_instance.read_instance(instanceId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling InstanceApi->readInstance: %s\n" % e)

extern crate InstanceApi;

pub fn main() {
    let instanceId = instanceId_example; // String

    let mut context = InstanceApi::Context::default();
    let result = client.readInstance(instanceId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.InstanceApi;

import java.io.File;
import java.util.*;

public class InstanceApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        InstanceApi apiInstance = new InstanceApi();
        String instanceId = instanceId_example; // String | The ID of the virtual machine instance.

        try {
            InstanceRemoteAccess result = apiInstance.readInstanceRemoteConnection(instanceId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling InstanceApi#readInstanceRemoteConnection");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String instanceId = new String(); // String | The ID of the virtual machine instance.

try {
    final result = await api_instance.readInstanceRemoteConnection(instanceId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->readInstanceRemoteConnection: $e\n');
}

import org.openapitools.client.api.InstanceApi;

public class InstanceApiExample {
    public static void main(String[] args) {
        InstanceApi apiInstance = new InstanceApi();
        String instanceId = instanceId_example; // String | The ID of the virtual machine instance.

        try {
            InstanceRemoteAccess result = apiInstance.readInstanceRemoteConnection(instanceId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling InstanceApi#readInstanceRemoteConnection");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
InstanceApi *apiInstance = [[InstanceApi alloc] init];
String *instanceId = instanceId_example; // The ID of the virtual machine instance. (default to null)

[apiInstance readInstanceRemoteConnectionWith:instanceId
              completionHandler: ^(InstanceRemoteAccess output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KowabungaApiDocumentation = require('kowabunga_api_documentation');
var defaultClient = KowabungaApiDocumentation.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new KowabungaApiDocumentation.InstanceApi()
var instanceId = instanceId_example; // {String} The ID of the virtual machine instance.

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.readInstanceRemoteConnection(instanceId, callback);

using System;
using System.Diagnostics;
using kowabunga.Api;
using kowabunga.Client;
using kowabunga.Model;

namespace Example
{
    public class readInstanceRemoteConnectionExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new InstanceApi();
            var instanceId = instanceId_example;  // String | The ID of the virtual machine instance. (default to null)

            try {
                InstanceRemoteAccess result = apiInstance.readInstanceRemoteConnection(instanceId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling InstanceApi.readInstanceRemoteConnection: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\InstanceApi();
$instanceId = instanceId_example; // String | The ID of the virtual machine instance.

try {
    $result = $api_instance->readInstanceRemoteConnection($instanceId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling InstanceApi->readInstanceRemoteConnection: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::InstanceApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::InstanceApi->new();
my $instanceId = instanceId_example; # String | The ID of the virtual machine instance.

eval {
    my $result = $api_instance->readInstanceRemoteConnection(instanceId => $instanceId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling InstanceApi->readInstanceRemoteConnection: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.InstanceApi()
instanceId = instanceId_example # String | The ID of the virtual machine instance. (default to null)

try:
    api_response = api_instance.read_instance_remote_connection(instanceId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling InstanceApi->readInstanceRemoteConnection: %s\n" % e)

extern crate InstanceApi;

pub fn main() {
    let instanceId = instanceId_example; // String

    let mut context = InstanceApi::Context::default();
    let result = client.readInstanceRemoteConnection(instanceId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.InstanceApi;

import java.io.File;
import java.util.*;

public class InstanceApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        InstanceApi apiInstance = new InstanceApi();
        String instanceId = instanceId_example; // String | The ID of the virtual machine instance.

        try {
            InstanceState result = apiInstance.readInstanceState(instanceId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling InstanceApi#readInstanceState");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String instanceId = new String(); // String | The ID of the virtual machine instance.

try {
    final result = await api_instance.readInstanceState(instanceId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->readInstanceState: $e\n');
}

import org.openapitools.client.api.InstanceApi;

public class InstanceApiExample {
    public static void main(String[] args) {
        InstanceApi apiInstance = new InstanceApi();
        String instanceId = instanceId_example; // String | The ID of the virtual machine instance.

        try {
            InstanceState result = apiInstance.readInstanceState(instanceId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling InstanceApi#readInstanceState");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
InstanceApi *apiInstance = [[InstanceApi alloc] init];
String *instanceId = instanceId_example; // The ID of the virtual machine instance. (default to null)

[apiInstance readInstanceStateWith:instanceId
              completionHandler: ^(InstanceState output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KowabungaApiDocumentation = require('kowabunga_api_documentation');
var defaultClient = KowabungaApiDocumentation.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new KowabungaApiDocumentation.InstanceApi()
var instanceId = instanceId_example; // {String} The ID of the virtual machine instance.

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.readInstanceState(instanceId, callback);

using System;
using System.Diagnostics;
using kowabunga.Api;
using kowabunga.Client;
using kowabunga.Model;

namespace Example
{
    public class readInstanceStateExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new InstanceApi();
            var instanceId = instanceId_example;  // String | The ID of the virtual machine instance. (default to null)

            try {
                InstanceState result = apiInstance.readInstanceState(instanceId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling InstanceApi.readInstanceState: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\InstanceApi();
$instanceId = instanceId_example; // String | The ID of the virtual machine instance.

try {
    $result = $api_instance->readInstanceState($instanceId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling InstanceApi->readInstanceState: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::InstanceApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::InstanceApi->new();
my $instanceId = instanceId_example; # String | The ID of the virtual machine instance.

eval {
    my $result = $api_instance->readInstanceState(instanceId => $instanceId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling InstanceApi->readInstanceState: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.InstanceApi()
instanceId = instanceId_example # String | The ID of the virtual machine instance. (default to null)

try:
    api_response = api_instance.read_instance_state(instanceId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling InstanceApi->readInstanceState: %s\n" % e)

extern crate InstanceApi;

pub fn main() {
    let instanceId = instanceId_example; // String

    let mut context = InstanceApi::Context::default();
    let result = client.readInstanceState(instanceId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.InstanceApi;

import java.io.File;
import java.util.*;

public class InstanceApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        InstanceApi apiInstance = new InstanceApi();
        String instanceId = instanceId_example; // String | The ID of the virtual machine instance.

        try {
            apiInstance.rebootInstance(instanceId);
        } catch (ApiException e) {
            System.err.println("Exception when calling InstanceApi#rebootInstance");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String instanceId = new String(); // String | The ID of the virtual machine instance.

try {
    final result = await api_instance.rebootInstance(instanceId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->rebootInstance: $e\n');
}

import org.openapitools.client.api.InstanceApi;

public class InstanceApiExample {
    public static void main(String[] args) {
        InstanceApi apiInstance = new InstanceApi();
        String instanceId = instanceId_example; // String | The ID of the virtual machine instance.

        try {
            apiInstance.rebootInstance(instanceId);
        } catch (ApiException e) {
            System.err.println("Exception when calling InstanceApi#rebootInstance");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
InstanceApi *apiInstance = [[InstanceApi alloc] init];
String *instanceId = instanceId_example; // The ID of the virtual machine instance. (default to null)

[apiInstance rebootInstanceWith:instanceId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KowabungaApiDocumentation = require('kowabunga_api_documentation');
var defaultClient = KowabungaApiDocumentation.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new KowabungaApiDocumentation.InstanceApi()
var instanceId = instanceId_example; // {String} The ID of the virtual machine instance.

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.rebootInstance(instanceId, callback);

using System;
using System.Diagnostics;
using kowabunga.Api;
using kowabunga.Client;
using kowabunga.Model;

namespace Example
{
    public class rebootInstanceExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new InstanceApi();
            var instanceId = instanceId_example;  // String | The ID of the virtual machine instance. (default to null)

            try {
                apiInstance.rebootInstance(instanceId);
            } catch (Exception e) {
                Debug.Print("Exception when calling InstanceApi.rebootInstance: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\InstanceApi();
$instanceId = instanceId_example; // String | The ID of the virtual machine instance.

try {
    $api_instance->rebootInstance($instanceId);
} catch (Exception $e) {
    echo 'Exception when calling InstanceApi->rebootInstance: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::InstanceApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::InstanceApi->new();
my $instanceId = instanceId_example; # String | The ID of the virtual machine instance.

eval {
    $api_instance->rebootInstance(instanceId => $instanceId);
};
if ($@) {
    warn "Exception when calling InstanceApi->rebootInstance: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.InstanceApi()
instanceId = instanceId_example # String | The ID of the virtual machine instance. (default to null)

try:
    api_instance.reboot_instance(instanceId)
except ApiException as e:
    print("Exception when calling InstanceApi->rebootInstance: %s\n" % e)

extern crate InstanceApi;

pub fn main() {
    let instanceId = instanceId_example; // String

    let mut context = InstanceApi::Context::default();
    let result = client.rebootInstance(instanceId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.InstanceApi;

import java.io.File;
import java.util.*;

public class InstanceApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        InstanceApi apiInstance = new InstanceApi();
        String instanceId = instanceId_example; // String | The ID of the virtual machine instance.

        try {
            apiInstance.resetInstance(instanceId);
        } catch (ApiException e) {
            System.err.println("Exception when calling InstanceApi#resetInstance");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String instanceId = new String(); // String | The ID of the virtual machine instance.

try {
    final result = await api_instance.resetInstance(instanceId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->resetInstance: $e\n');
}

import org.openapitools.client.api.InstanceApi;

public class InstanceApiExample {
    public static void main(String[] args) {
        InstanceApi apiInstance = new InstanceApi();
        String instanceId = instanceId_example; // String | The ID of the virtual machine instance.

        try {
            apiInstance.resetInstance(instanceId);
        } catch (ApiException e) {
            System.err.println("Exception when calling InstanceApi#resetInstance");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
InstanceApi *apiInstance = [[InstanceApi alloc] init];
String *instanceId = instanceId_example; // The ID of the virtual machine instance. (default to null)

[apiInstance resetInstanceWith:instanceId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KowabungaApiDocumentation = require('kowabunga_api_documentation');
var defaultClient = KowabungaApiDocumentation.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new KowabungaApiDocumentation.InstanceApi()
var instanceId = instanceId_example; // {String} The ID of the virtual machine instance.

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.resetInstance(instanceId, callback);

using System;
using System.Diagnostics;
using kowabunga.Api;
using kowabunga.Client;
using kowabunga.Model;

namespace Example
{
    public class resetInstanceExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new InstanceApi();
            var instanceId = instanceId_example;  // String | The ID of the virtual machine instance. (default to null)

            try {
                apiInstance.resetInstance(instanceId);
            } catch (Exception e) {
                Debug.Print("Exception when calling InstanceApi.resetInstance: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\InstanceApi();
$instanceId = instanceId_example; // String | The ID of the virtual machine instance.

try {
    $api_instance->resetInstance($instanceId);
} catch (Exception $e) {
    echo 'Exception when calling InstanceApi->resetInstance: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::InstanceApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::InstanceApi->new();
my $instanceId = instanceId_example; # String | The ID of the virtual machine instance.

eval {
    $api_instance->resetInstance(instanceId => $instanceId);
};
if ($@) {
    warn "Exception when calling InstanceApi->resetInstance: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.InstanceApi()
instanceId = instanceId_example # String | The ID of the virtual machine instance. (default to null)

try:
    api_instance.reset_instance(instanceId)
except ApiException as e:
    print("Exception when calling InstanceApi->resetInstance: %s\n" % e)

extern crate InstanceApi;

pub fn main() {
    let instanceId = instanceId_example; // String

    let mut context = InstanceApi::Context::default();
    let result = client.resetInstance(instanceId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.InstanceApi;

import java.io.File;
import java.util.*;

public class InstanceApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        InstanceApi apiInstance = new InstanceApi();
        String instanceId = instanceId_example; // String | The ID of the virtual machine instance.

        try {
            apiInstance.resumeInstance(instanceId);
        } catch (ApiException e) {
            System.err.println("Exception when calling InstanceApi#resumeInstance");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String instanceId = new String(); // String | The ID of the virtual machine instance.

try {
    final result = await api_instance.resumeInstance(instanceId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->resumeInstance: $e\n');
}

import org.openapitools.client.api.InstanceApi;

public class InstanceApiExample {
    public static void main(String[] args) {
        InstanceApi apiInstance = new InstanceApi();
        String instanceId = instanceId_example; // String | The ID of the virtual machine instance.

        try {
            apiInstance.resumeInstance(instanceId);
        } catch (ApiException e) {
            System.err.println("Exception when calling InstanceApi#resumeInstance");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
InstanceApi *apiInstance = [[InstanceApi alloc] init];
String *instanceId = instanceId_example; // The ID of the virtual machine instance. (default to null)

[apiInstance resumeInstanceWith:instanceId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KowabungaApiDocumentation = require('kowabunga_api_documentation');
var defaultClient = KowabungaApiDocumentation.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new KowabungaApiDocumentation.InstanceApi()
var instanceId = instanceId_example; // {String} The ID of the virtual machine instance.

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.resumeInstance(instanceId, callback);

using System;
using System.Diagnostics;
using kowabunga.Api;
using kowabunga.Client;
using kowabunga.Model;

namespace Example
{
    public class resumeInstanceExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new InstanceApi();
            var instanceId = instanceId_example;  // String | The ID of the virtual machine instance. (default to null)

            try {
                apiInstance.resumeInstance(instanceId);
            } catch (Exception e) {
                Debug.Print("Exception when calling InstanceApi.resumeInstance: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\InstanceApi();
$instanceId = instanceId_example; // String | The ID of the virtual machine instance.

try {
    $api_instance->resumeInstance($instanceId);
} catch (Exception $e) {
    echo 'Exception when calling InstanceApi->resumeInstance: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::InstanceApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::InstanceApi->new();
my $instanceId = instanceId_example; # String | The ID of the virtual machine instance.

eval {
    $api_instance->resumeInstance(instanceId => $instanceId);
};
if ($@) {
    warn "Exception when calling InstanceApi->resumeInstance: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.InstanceApi()
instanceId = instanceId_example # String | The ID of the virtual machine instance. (default to null)

try:
    api_instance.resume_instance(instanceId)
except ApiException as e:
    print("Exception when calling InstanceApi->resumeInstance: %s\n" % e)

extern crate InstanceApi;

pub fn main() {
    let instanceId = instanceId_example; // String

    let mut context = InstanceApi::Context::default();
    let result = client.resumeInstance(instanceId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.InstanceApi;

import java.io.File;
import java.util.*;

public class InstanceApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        InstanceApi apiInstance = new InstanceApi();
        String instanceId = instanceId_example; // String | The ID of the virtual machine instance.

        try {
            apiInstance.shutdownInstance(instanceId);
        } catch (ApiException e) {
            System.err.println("Exception when calling InstanceApi#shutdownInstance");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String instanceId = new String(); // String | The ID of the virtual machine instance.

try {
    final result = await api_instance.shutdownInstance(instanceId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->shutdownInstance: $e\n');
}

import org.openapitools.client.api.InstanceApi;

public class InstanceApiExample {
    public static void main(String[] args) {
        InstanceApi apiInstance = new InstanceApi();
        String instanceId = instanceId_example; // String | The ID of the virtual machine instance.

        try {
            apiInstance.shutdownInstance(instanceId);
        } catch (ApiException e) {
            System.err.println("Exception when calling InstanceApi#shutdownInstance");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
InstanceApi *apiInstance = [[InstanceApi alloc] init];
String *instanceId = instanceId_example; // The ID of the virtual machine instance. (default to null)

[apiInstance shutdownInstanceWith:instanceId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KowabungaApiDocumentation = require('kowabunga_api_documentation');
var defaultClient = KowabungaApiDocumentation.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new KowabungaApiDocumentation.InstanceApi()
var instanceId = instanceId_example; // {String} The ID of the virtual machine instance.

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.shutdownInstance(instanceId, callback);

using System;
using System.Diagnostics;
using kowabunga.Api;
using kowabunga.Client;
using kowabunga.Model;

namespace Example
{
    public class shutdownInstanceExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new InstanceApi();
            var instanceId = instanceId_example;  // String | The ID of the virtual machine instance. (default to null)

            try {
                apiInstance.shutdownInstance(instanceId);
            } catch (Exception e) {
                Debug.Print("Exception when calling InstanceApi.shutdownInstance: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\InstanceApi();
$instanceId = instanceId_example; // String | The ID of the virtual machine instance.

try {
    $api_instance->shutdownInstance($instanceId);
} catch (Exception $e) {
    echo 'Exception when calling InstanceApi->shutdownInstance: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::InstanceApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::InstanceApi->new();
my $instanceId = instanceId_example; # String | The ID of the virtual machine instance.

eval {
    $api_instance->shutdownInstance(instanceId => $instanceId);
};
if ($@) {
    warn "Exception when calling InstanceApi->shutdownInstance: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.InstanceApi()
instanceId = instanceId_example # String | The ID of the virtual machine instance. (default to null)

try:
    api_instance.shutdown_instance(instanceId)
except ApiException as e:
    print("Exception when calling InstanceApi->shutdownInstance: %s\n" % e)

extern crate InstanceApi;

pub fn main() {
    let instanceId = instanceId_example; // String

    let mut context = InstanceApi::Context::default();
    let result = client.shutdownInstance(instanceId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.InstanceApi;

import java.io.File;
import java.util.*;

public class InstanceApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        InstanceApi apiInstance = new InstanceApi();
        String instanceId = instanceId_example; // String | The ID of the virtual machine instance.

        try {
            apiInstance.startInstance(instanceId);
        } catch (ApiException e) {
            System.err.println("Exception when calling InstanceApi#startInstance");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String instanceId = new String(); // String | The ID of the virtual machine instance.

try {
    final result = await api_instance.startInstance(instanceId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->startInstance: $e\n');
}

import org.openapitools.client.api.InstanceApi;

public class InstanceApiExample {
    public static void main(String[] args) {
        InstanceApi apiInstance = new InstanceApi();
        String instanceId = instanceId_example; // String | The ID of the virtual machine instance.

        try {
            apiInstance.startInstance(instanceId);
        } catch (ApiException e) {
            System.err.println("Exception when calling InstanceApi#startInstance");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
InstanceApi *apiInstance = [[InstanceApi alloc] init];
String *instanceId = instanceId_example; // The ID of the virtual machine instance. (default to null)

[apiInstance startInstanceWith:instanceId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KowabungaApiDocumentation = require('kowabunga_api_documentation');
var defaultClient = KowabungaApiDocumentation.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new KowabungaApiDocumentation.InstanceApi()
var instanceId = instanceId_example; // {String} The ID of the virtual machine instance.

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.startInstance(instanceId, callback);

using System;
using System.Diagnostics;
using kowabunga.Api;
using kowabunga.Client;
using kowabunga.Model;

namespace Example
{
    public class startInstanceExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new InstanceApi();
            var instanceId = instanceId_example;  // String | The ID of the virtual machine instance. (default to null)

            try {
                apiInstance.startInstance(instanceId);
            } catch (Exception e) {
                Debug.Print("Exception when calling InstanceApi.startInstance: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\InstanceApi();
$instanceId = instanceId_example; // String | The ID of the virtual machine instance.

try {
    $api_instance->startInstance($instanceId);
} catch (Exception $e) {
    echo 'Exception when calling InstanceApi->startInstance: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::InstanceApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::InstanceApi->new();
my $instanceId = instanceId_example; # String | The ID of the virtual machine instance.

eval {
    $api_instance->startInstance(instanceId => $instanceId);
};
if ($@) {
    warn "Exception when calling InstanceApi->startInstance: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.InstanceApi()
instanceId = instanceId_example # String | The ID of the virtual machine instance. (default to null)

try:
    api_instance.start_instance(instanceId)
except ApiException as e:
    print("Exception when calling InstanceApi->startInstance: %s\n" % e)

extern crate InstanceApi;

pub fn main() {
    let instanceId = instanceId_example; // String

    let mut context = InstanceApi::Context::default();
    let result = client.startInstance(instanceId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.InstanceApi;

import java.io.File;
import java.util.*;

public class InstanceApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        InstanceApi apiInstance = new InstanceApi();
        String instanceId = instanceId_example; // String | The ID of the virtual machine instance.

        try {
            apiInstance.stopInstance(instanceId);
        } catch (ApiException e) {
            System.err.println("Exception when calling InstanceApi#stopInstance");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String instanceId = new String(); // String | The ID of the virtual machine instance.

try {
    final result = await api_instance.stopInstance(instanceId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->stopInstance: $e\n');
}

import org.openapitools.client.api.InstanceApi;

public class InstanceApiExample {
    public static void main(String[] args) {
        InstanceApi apiInstance = new InstanceApi();
        String instanceId = instanceId_example; // String | The ID of the virtual machine instance.

        try {
            apiInstance.stopInstance(instanceId);
        } catch (ApiException e) {
            System.err.println("Exception when calling InstanceApi#stopInstance");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
InstanceApi *apiInstance = [[InstanceApi alloc] init];
String *instanceId = instanceId_example; // The ID of the virtual machine instance. (default to null)

[apiInstance stopInstanceWith:instanceId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KowabungaApiDocumentation = require('kowabunga_api_documentation');
var defaultClient = KowabungaApiDocumentation.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new KowabungaApiDocumentation.InstanceApi()
var instanceId = instanceId_example; // {String} The ID of the virtual machine instance.

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.stopInstance(instanceId, callback);

using System;
using System.Diagnostics;
using kowabunga.Api;
using kowabunga.Client;
using kowabunga.Model;

namespace Example
{
    public class stopInstanceExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new InstanceApi();
            var instanceId = instanceId_example;  // String | The ID of the virtual machine instance. (default to null)

            try {
                apiInstance.stopInstance(instanceId);
            } catch (Exception e) {
                Debug.Print("Exception when calling InstanceApi.stopInstance: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\InstanceApi();
$instanceId = instanceId_example; // String | The ID of the virtual machine instance.

try {
    $api_instance->stopInstance($instanceId);
} catch (Exception $e) {
    echo 'Exception when calling InstanceApi->stopInstance: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::InstanceApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::InstanceApi->new();
my $instanceId = instanceId_example; # String | The ID of the virtual machine instance.

eval {
    $api_instance->stopInstance(instanceId => $instanceId);
};
if ($@) {
    warn "Exception when calling InstanceApi->stopInstance: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.InstanceApi()
instanceId = instanceId_example # String | The ID of the virtual machine instance. (default to null)

try:
    api_instance.stop_instance(instanceId)
except ApiException as e:
    print("Exception when calling InstanceApi->stopInstance: %s\n" % e)

extern crate InstanceApi;

pub fn main() {
    let instanceId = instanceId_example; // String

    let mut context = InstanceApi::Context::default();
    let result = client.stopInstance(instanceId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.InstanceApi;

import java.io.File;
import java.util.*;

public class InstanceApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        InstanceApi apiInstance = new InstanceApi();
        String instanceId = instanceId_example; // String | The ID of the virtual machine instance.

        try {
            apiInstance.suspendInstance(instanceId);
        } catch (ApiException e) {
            System.err.println("Exception when calling InstanceApi#suspendInstance");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String instanceId = new String(); // String | The ID of the virtual machine instance.

try {
    final result = await api_instance.suspendInstance(instanceId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->suspendInstance: $e\n');
}

import org.openapitools.client.api.InstanceApi;

public class InstanceApiExample {
    public static void main(String[] args) {
        InstanceApi apiInstance = new InstanceApi();
        String instanceId = instanceId_example; // String | The ID of the virtual machine instance.

        try {
            apiInstance.suspendInstance(instanceId);
        } catch (ApiException e) {
            System.err.println("Exception when calling InstanceApi#suspendInstance");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
InstanceApi *apiInstance = [[InstanceApi alloc] init];
String *instanceId = instanceId_example; // The ID of the virtual machine instance. (default to null)

[apiInstance suspendInstanceWith:instanceId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KowabungaApiDocumentation = require('kowabunga_api_documentation');
var defaultClient = KowabungaApiDocumentation.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new KowabungaApiDocumentation.InstanceApi()
var instanceId = instanceId_example; // {String} The ID of the virtual machine instance.

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.suspendInstance(instanceId, callback);

using System;
using System.Diagnostics;
using kowabunga.Api;
using kowabunga.Client;
using kowabunga.Model;

namespace Example
{
    public class suspendInstanceExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new InstanceApi();
            var instanceId = instanceId_example;  // String | The ID of the virtual machine instance. (default to null)

            try {
                apiInstance.suspendInstance(instanceId);
            } catch (Exception e) {
                Debug.Print("Exception when calling InstanceApi.suspendInstance: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\InstanceApi();
$instanceId = instanceId_example; // String | The ID of the virtual machine instance.

try {
    $api_instance->suspendInstance($instanceId);
} catch (Exception $e) {
    echo 'Exception when calling InstanceApi->suspendInstance: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::InstanceApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::InstanceApi->new();
my $instanceId = instanceId_example; # String | The ID of the virtual machine instance.

eval {
    $api_instance->suspendInstance(instanceId => $instanceId);
};
if ($@) {
    warn "Exception when calling InstanceApi->suspendInstance: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.InstanceApi()
instanceId = instanceId_example # String | The ID of the virtual machine instance. (default to null)

try:
    api_instance.suspend_instance(instanceId)
except ApiException as e:
    print("Exception when calling InstanceApi->suspendInstance: %s\n" % e)

extern crate InstanceApi;

pub fn main() {
    let instanceId = instanceId_example; // String

    let mut context = InstanceApi::Context::default();
    let result = client.suspendInstance(instanceId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.InstanceApi;

import java.io.File;
import java.util.*;

public class InstanceApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        InstanceApi apiInstance = new InstanceApi();
        String instanceId = instanceId_example; // String | The ID of the virtual machine instance.
        Instance instance = ; // Instance | 

        try {
            Instance result = apiInstance.updateInstance(instanceId, instance);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling InstanceApi#updateInstance");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String instanceId = new String(); // String | The ID of the virtual machine instance.
final Instance instance = new Instance(); // Instance | 

try {
    final result = await api_instance.updateInstance(instanceId, instance);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->updateInstance: $e\n');
}

import org.openapitools.client.api.InstanceApi;

public class InstanceApiExample {
    public static void main(String[] args) {
        InstanceApi apiInstance = new InstanceApi();
        String instanceId = instanceId_example; // String | The ID of the virtual machine instance.
        Instance instance = ; // Instance | 

        try {
            Instance result = apiInstance.updateInstance(instanceId, instance);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling InstanceApi#updateInstance");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
InstanceApi *apiInstance = [[InstanceApi alloc] init];
String *instanceId = instanceId_example; // The ID of the virtual machine instance. (default to null)
Instance *instance = ; // 

[apiInstance updateInstanceWith:instanceId
    instance:instance
              completionHandler: ^(Instance output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KowabungaApiDocumentation = require('kowabunga_api_documentation');
var defaultClient = KowabungaApiDocumentation.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new KowabungaApiDocumentation.InstanceApi()
var instanceId = instanceId_example; // {String} The ID of the virtual machine instance.
var instance = ; // {Instance} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateInstance(instanceId, instance, callback);

using System;
using System.Diagnostics;
using kowabunga.Api;
using kowabunga.Client;
using kowabunga.Model;

namespace Example
{
    public class updateInstanceExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new InstanceApi();
            var instanceId = instanceId_example;  // String | The ID of the virtual machine instance. (default to null)
            var instance = new Instance(); // Instance | 

            try {
                Instance result = apiInstance.updateInstance(instanceId, instance);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling InstanceApi.updateInstance: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\InstanceApi();
$instanceId = instanceId_example; // String | The ID of the virtual machine instance.
$instance = ; // Instance | 

try {
    $result = $api_instance->updateInstance($instanceId, $instance);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling InstanceApi->updateInstance: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::InstanceApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::InstanceApi->new();
my $instanceId = instanceId_example; # String | The ID of the virtual machine instance.
my $instance = WWW::OPenAPIClient::Object::Instance->new(); # Instance | 

eval {
    my $result = $api_instance->updateInstance(instanceId => $instanceId, instance => $instance);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling InstanceApi->updateInstance: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.InstanceApi()
instanceId = instanceId_example # String | The ID of the virtual machine instance. (default to null)
instance =  # Instance | 

try:
    api_response = api_instance.update_instance(instanceId, instance)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling InstanceApi->updateInstance: %s\n" % e)

extern crate InstanceApi;

pub fn main() {
    let instanceId = instanceId_example; // String
    let instance = ; // Instance

    let mut context = InstanceApi::Context::default();
    let result = client.updateInstance(instanceId, instance, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KaktusApi;

import java.io.File;
import java.util.*;

public class KaktusApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        KaktusApi apiInstance = new KaktusApi();
        String zoneId = zoneId_example; // String | The ID of the availability zone.
        Kaktus kaktus = ; // Kaktus | 

        try {
            Kaktus result = apiInstance.createKaktus(zoneId, kaktus);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KaktusApi#createKaktus");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String zoneId = new String(); // String | The ID of the availability zone.
final Kaktus kaktus = new Kaktus(); // Kaktus | 

try {
    final result = await api_instance.createKaktus(zoneId, kaktus);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->createKaktus: $e\n');
}

import org.openapitools.client.api.KaktusApi;

public class KaktusApiExample {
    public static void main(String[] args) {
        KaktusApi apiInstance = new KaktusApi();
        String zoneId = zoneId_example; // String | The ID of the availability zone.
        Kaktus kaktus = ; // Kaktus | 

        try {
            Kaktus result = apiInstance.createKaktus(zoneId, kaktus);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KaktusApi#createKaktus");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
KaktusApi *apiInstance = [[KaktusApi alloc] init];
String *zoneId = zoneId_example; // The ID of the availability zone. (default to null)
Kaktus *kaktus = ; // 

[apiInstance createKaktusWith:zoneId
    kaktus:kaktus
              completionHandler: ^(Kaktus output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KowabungaApiDocumentation = require('kowabunga_api_documentation');
var defaultClient = KowabungaApiDocumentation.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new KowabungaApiDocumentation.KaktusApi()
var zoneId = zoneId_example; // {String} The ID of the availability zone.
var kaktus = ; // {Kaktus} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createKaktus(zoneId, kaktus, callback);

using System;
using System.Diagnostics;
using kowabunga.Api;
using kowabunga.Client;
using kowabunga.Model;

namespace Example
{
    public class createKaktusExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new KaktusApi();
            var zoneId = zoneId_example;  // String | The ID of the availability zone. (default to null)
            var kaktus = new Kaktus(); // Kaktus | 

            try {
                Kaktus result = apiInstance.createKaktus(zoneId, kaktus);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KaktusApi.createKaktus: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KaktusApi();
$zoneId = zoneId_example; // String | The ID of the availability zone.
$kaktus = ; // Kaktus | 

try {
    $result = $api_instance->createKaktus($zoneId, $kaktus);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling KaktusApi->createKaktus: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KaktusApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KaktusApi->new();
my $zoneId = zoneId_example; # String | The ID of the availability zone.
my $kaktus = WWW::OPenAPIClient::Object::Kaktus->new(); # Kaktus | 

eval {
    my $result = $api_instance->createKaktus(zoneId => $zoneId, kaktus => $kaktus);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KaktusApi->createKaktus: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.KaktusApi()
zoneId = zoneId_example # String | The ID of the availability zone. (default to null)
kaktus =  # Kaktus | 

try:
    api_response = api_instance.create_kaktus(zoneId, kaktus)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KaktusApi->createKaktus: %s\n" % e)

extern crate KaktusApi;

pub fn main() {
    let zoneId = zoneId_example; // String
    let kaktus = ; // Kaktus

    let mut context = KaktusApi::Context::default();
    let result = client.createKaktus(zoneId, kaktus, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KaktusApi;

import java.io.File;
import java.util.*;

public class KaktusApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        KaktusApi apiInstance = new KaktusApi();
        String kaktusId = kaktusId_example; // String | The ID of the Kaktus computing node.

        try {
            apiInstance.deleteKaktus(kaktusId);
        } catch (ApiException e) {
            System.err.println("Exception when calling KaktusApi#deleteKaktus");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String kaktusId = new String(); // String | The ID of the Kaktus computing node.

try {
    final result = await api_instance.deleteKaktus(kaktusId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteKaktus: $e\n');
}

import org.openapitools.client.api.KaktusApi;

public class KaktusApiExample {
    public static void main(String[] args) {
        KaktusApi apiInstance = new KaktusApi();
        String kaktusId = kaktusId_example; // String | The ID of the Kaktus computing node.

        try {
            apiInstance.deleteKaktus(kaktusId);
        } catch (ApiException e) {
            System.err.println("Exception when calling KaktusApi#deleteKaktus");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
KaktusApi *apiInstance = [[KaktusApi alloc] init];
String *kaktusId = kaktusId_example; // The ID of the Kaktus computing node. (default to null)

[apiInstance deleteKaktusWith:kaktusId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KowabungaApiDocumentation = require('kowabunga_api_documentation');
var defaultClient = KowabungaApiDocumentation.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new KowabungaApiDocumentation.KaktusApi()
var kaktusId = kaktusId_example; // {String} The ID of the Kaktus computing node.

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteKaktus(kaktusId, callback);

using System;
using System.Diagnostics;
using kowabunga.Api;
using kowabunga.Client;
using kowabunga.Model;

namespace Example
{
    public class deleteKaktusExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new KaktusApi();
            var kaktusId = kaktusId_example;  // String | The ID of the Kaktus computing node. (default to null)

            try {
                apiInstance.deleteKaktus(kaktusId);
            } catch (Exception e) {
                Debug.Print("Exception when calling KaktusApi.deleteKaktus: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KaktusApi();
$kaktusId = kaktusId_example; // String | The ID of the Kaktus computing node.

try {
    $api_instance->deleteKaktus($kaktusId);
} catch (Exception $e) {
    echo 'Exception when calling KaktusApi->deleteKaktus: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KaktusApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KaktusApi->new();
my $kaktusId = kaktusId_example; # String | The ID of the Kaktus computing node.

eval {
    $api_instance->deleteKaktus(kaktusId => $kaktusId);
};
if ($@) {
    warn "Exception when calling KaktusApi->deleteKaktus: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.KaktusApi()
kaktusId = kaktusId_example # String | The ID of the Kaktus computing node. (default to null)

try:
    api_instance.delete_kaktus(kaktusId)
except ApiException as e:
    print("Exception when calling KaktusApi->deleteKaktus: %s\n" % e)

extern crate KaktusApi;

pub fn main() {
    let kaktusId = kaktusId_example; // String

    let mut context = KaktusApi::Context::default();
    let result = client.deleteKaktus(kaktusId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KaktusApi;

import java.io.File;
import java.util.*;

public class KaktusApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        KaktusApi apiInstance = new KaktusApi();
        String kaktusId = kaktusId_example; // String | The ID of the Kaktus computing node.

        try {
            array['String'] result = apiInstance.listKaktusInstances(kaktusId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KaktusApi#listKaktusInstances");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String kaktusId = new String(); // String | The ID of the Kaktus computing node.

try {
    final result = await api_instance.listKaktusInstances(kaktusId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->listKaktusInstances: $e\n');
}

import org.openapitools.client.api.KaktusApi;

public class KaktusApiExample {
    public static void main(String[] args) {
        KaktusApi apiInstance = new KaktusApi();
        String kaktusId = kaktusId_example; // String | The ID of the Kaktus computing node.

        try {
            array['String'] result = apiInstance.listKaktusInstances(kaktusId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KaktusApi#listKaktusInstances");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
KaktusApi *apiInstance = [[KaktusApi alloc] init];
String *kaktusId = kaktusId_example; // The ID of the Kaktus computing node. (default to null)

[apiInstance listKaktusInstancesWith:kaktusId
              completionHandler: ^(array['String'] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KowabungaApiDocumentation = require('kowabunga_api_documentation');
var defaultClient = KowabungaApiDocumentation.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new KowabungaApiDocumentation.KaktusApi()
var kaktusId = kaktusId_example; // {String} The ID of the Kaktus computing node.

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listKaktusInstances(kaktusId, callback);

using System;
using System.Diagnostics;
using kowabunga.Api;
using kowabunga.Client;
using kowabunga.Model;

namespace Example
{
    public class listKaktusInstancesExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new KaktusApi();
            var kaktusId = kaktusId_example;  // String | The ID of the Kaktus computing node. (default to null)

            try {
                array['String'] result = apiInstance.listKaktusInstances(kaktusId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KaktusApi.listKaktusInstances: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KaktusApi();
$kaktusId = kaktusId_example; // String | The ID of the Kaktus computing node.

try {
    $result = $api_instance->listKaktusInstances($kaktusId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling KaktusApi->listKaktusInstances: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KaktusApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KaktusApi->new();
my $kaktusId = kaktusId_example; # String | The ID of the Kaktus computing node.

eval {
    my $result = $api_instance->listKaktusInstances(kaktusId => $kaktusId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KaktusApi->listKaktusInstances: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.KaktusApi()
kaktusId = kaktusId_example # String | The ID of the Kaktus computing node. (default to null)

try:
    api_response = api_instance.list_kaktus_instances(kaktusId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KaktusApi->listKaktusInstances: %s\n" % e)

extern crate KaktusApi;

pub fn main() {
    let kaktusId = kaktusId_example; // String

    let mut context = KaktusApi::Context::default();
    let result = client.listKaktusInstances(kaktusId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KaktusApi;

import java.io.File;
import java.util.*;

public class KaktusApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        KaktusApi apiInstance = new KaktusApi();

        try {
            array['String'] result = apiInstance.listKaktuss();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KaktusApi#listKaktuss");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.listKaktuss();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->listKaktuss: $e\n');
}

import org.openapitools.client.api.KaktusApi;

public class KaktusApiExample {
    public static void main(String[] args) {
        KaktusApi apiInstance = new KaktusApi();

        try {
            array['String'] result = apiInstance.listKaktuss();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KaktusApi#listKaktuss");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
KaktusApi *apiInstance = [[KaktusApi alloc] init];

[apiInstance listKaktussWithCompletionHandler: 
              ^(array['String'] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KowabungaApiDocumentation = require('kowabunga_api_documentation');
var defaultClient = KowabungaApiDocumentation.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new KowabungaApiDocumentation.KaktusApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listKaktuss(callback);

using System;
using System.Diagnostics;
using kowabunga.Api;
using kowabunga.Client;
using kowabunga.Model;

namespace Example
{
    public class listKaktussExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new KaktusApi();

            try {
                array['String'] result = apiInstance.listKaktuss();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KaktusApi.listKaktuss: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KaktusApi();

try {
    $result = $api_instance->listKaktuss();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling KaktusApi->listKaktuss: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KaktusApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KaktusApi->new();

eval {
    my $result = $api_instance->listKaktuss();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KaktusApi->listKaktuss: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.KaktusApi()

try:
    api_response = api_instance.list_kaktuss()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KaktusApi->listKaktuss: %s\n" % e)

extern crate KaktusApi;

pub fn main() {

    let mut context = KaktusApi::Context::default();
    let result = client.listKaktuss(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KaktusApi;

import java.io.File;
import java.util.*;

public class KaktusApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        KaktusApi apiInstance = new KaktusApi();
        String zoneId = zoneId_example; // String | The ID of the availability zone.

        try {
            array['String'] result = apiInstance.listZoneKaktuses(zoneId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KaktusApi#listZoneKaktuses");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String zoneId = new String(); // String | The ID of the availability zone.

try {
    final result = await api_instance.listZoneKaktuses(zoneId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->listZoneKaktuses: $e\n');
}

import org.openapitools.client.api.KaktusApi;

public class KaktusApiExample {
    public static void main(String[] args) {
        KaktusApi apiInstance = new KaktusApi();
        String zoneId = zoneId_example; // String | The ID of the availability zone.

        try {
            array['String'] result = apiInstance.listZoneKaktuses(zoneId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KaktusApi#listZoneKaktuses");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
KaktusApi *apiInstance = [[KaktusApi alloc] init];
String *zoneId = zoneId_example; // The ID of the availability zone. (default to null)

[apiInstance listZoneKaktusesWith:zoneId
              completionHandler: ^(array['String'] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KowabungaApiDocumentation = require('kowabunga_api_documentation');
var defaultClient = KowabungaApiDocumentation.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new KowabungaApiDocumentation.KaktusApi()
var zoneId = zoneId_example; // {String} The ID of the availability zone.

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listZoneKaktuses(zoneId, callback);

using System;
using System.Diagnostics;
using kowabunga.Api;
using kowabunga.Client;
using kowabunga.Model;

namespace Example
{
    public class listZoneKaktusesExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new KaktusApi();
            var zoneId = zoneId_example;  // String | The ID of the availability zone. (default to null)

            try {
                array['String'] result = apiInstance.listZoneKaktuses(zoneId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KaktusApi.listZoneKaktuses: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KaktusApi();
$zoneId = zoneId_example; // String | The ID of the availability zone.

try {
    $result = $api_instance->listZoneKaktuses($zoneId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling KaktusApi->listZoneKaktuses: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KaktusApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KaktusApi->new();
my $zoneId = zoneId_example; # String | The ID of the availability zone.

eval {
    my $result = $api_instance->listZoneKaktuses(zoneId => $zoneId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KaktusApi->listZoneKaktuses: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.KaktusApi()
zoneId = zoneId_example # String | The ID of the availability zone. (default to null)

try:
    api_response = api_instance.list_zone_kaktuses(zoneId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KaktusApi->listZoneKaktuses: %s\n" % e)

extern crate KaktusApi;

pub fn main() {
    let zoneId = zoneId_example; // String

    let mut context = KaktusApi::Context::default();
    let result = client.listZoneKaktuses(zoneId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KaktusApi;

import java.io.File;
import java.util.*;

public class KaktusApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        KaktusApi apiInstance = new KaktusApi();
        String kaktusId = kaktusId_example; // String | The ID of the Kaktus computing node.

        try {
            Kaktus result = apiInstance.readKaktus(kaktusId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KaktusApi#readKaktus");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String kaktusId = new String(); // String | The ID of the Kaktus computing node.

try {
    final result = await api_instance.readKaktus(kaktusId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->readKaktus: $e\n');
}

import org.openapitools.client.api.KaktusApi;

public class KaktusApiExample {
    public static void main(String[] args) {
        KaktusApi apiInstance = new KaktusApi();
        String kaktusId = kaktusId_example; // String | The ID of the Kaktus computing node.

        try {
            Kaktus result = apiInstance.readKaktus(kaktusId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KaktusApi#readKaktus");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
KaktusApi *apiInstance = [[KaktusApi alloc] init];
String *kaktusId = kaktusId_example; // The ID of the Kaktus computing node. (default to null)

[apiInstance readKaktusWith:kaktusId
              completionHandler: ^(Kaktus output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KowabungaApiDocumentation = require('kowabunga_api_documentation');
var defaultClient = KowabungaApiDocumentation.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new KowabungaApiDocumentation.KaktusApi()
var kaktusId = kaktusId_example; // {String} The ID of the Kaktus computing node.

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.readKaktus(kaktusId, callback);

using System;
using System.Diagnostics;
using kowabunga.Api;
using kowabunga.Client;
using kowabunga.Model;

namespace Example
{
    public class readKaktusExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new KaktusApi();
            var kaktusId = kaktusId_example;  // String | The ID of the Kaktus computing node. (default to null)

            try {
                Kaktus result = apiInstance.readKaktus(kaktusId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KaktusApi.readKaktus: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KaktusApi();
$kaktusId = kaktusId_example; // String | The ID of the Kaktus computing node.

try {
    $result = $api_instance->readKaktus($kaktusId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling KaktusApi->readKaktus: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KaktusApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KaktusApi->new();
my $kaktusId = kaktusId_example; # String | The ID of the Kaktus computing node.

eval {
    my $result = $api_instance->readKaktus(kaktusId => $kaktusId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KaktusApi->readKaktus: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.KaktusApi()
kaktusId = kaktusId_example # String | The ID of the Kaktus computing node. (default to null)

try:
    api_response = api_instance.read_kaktus(kaktusId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KaktusApi->readKaktus: %s\n" % e)

extern crate KaktusApi;

pub fn main() {
    let kaktusId = kaktusId_example; // String

    let mut context = KaktusApi::Context::default();
    let result = client.readKaktus(kaktusId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KaktusApi;

import java.io.File;
import java.util.*;

public class KaktusApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        KaktusApi apiInstance = new KaktusApi();
        String kaktusId = kaktusId_example; // String | The ID of the Kaktus computing node.

        try {
            KaktusCaps result = apiInstance.readKaktusCaps(kaktusId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KaktusApi#readKaktusCaps");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String kaktusId = new String(); // String | The ID of the Kaktus computing node.

try {
    final result = await api_instance.readKaktusCaps(kaktusId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->readKaktusCaps: $e\n');
}

import org.openapitools.client.api.KaktusApi;

public class KaktusApiExample {
    public static void main(String[] args) {
        KaktusApi apiInstance = new KaktusApi();
        String kaktusId = kaktusId_example; // String | The ID of the Kaktus computing node.

        try {
            KaktusCaps result = apiInstance.readKaktusCaps(kaktusId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KaktusApi#readKaktusCaps");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
KaktusApi *apiInstance = [[KaktusApi alloc] init];
String *kaktusId = kaktusId_example; // The ID of the Kaktus computing node. (default to null)

[apiInstance readKaktusCapsWith:kaktusId
              completionHandler: ^(KaktusCaps output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KowabungaApiDocumentation = require('kowabunga_api_documentation');
var defaultClient = KowabungaApiDocumentation.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new KowabungaApiDocumentation.KaktusApi()
var kaktusId = kaktusId_example; // {String} The ID of the Kaktus computing node.

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.readKaktusCaps(kaktusId, callback);

using System;
using System.Diagnostics;
using kowabunga.Api;
using kowabunga.Client;
using kowabunga.Model;

namespace Example
{
    public class readKaktusCapsExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new KaktusApi();
            var kaktusId = kaktusId_example;  // String | The ID of the Kaktus computing node. (default to null)

            try {
                KaktusCaps result = apiInstance.readKaktusCaps(kaktusId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KaktusApi.readKaktusCaps: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KaktusApi();
$kaktusId = kaktusId_example; // String | The ID of the Kaktus computing node.

try {
    $result = $api_instance->readKaktusCaps($kaktusId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling KaktusApi->readKaktusCaps: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KaktusApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KaktusApi->new();
my $kaktusId = kaktusId_example; # String | The ID of the Kaktus computing node.

eval {
    my $result = $api_instance->readKaktusCaps(kaktusId => $kaktusId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KaktusApi->readKaktusCaps: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.KaktusApi()
kaktusId = kaktusId_example # String | The ID of the Kaktus computing node. (default to null)

try:
    api_response = api_instance.read_kaktus_caps(kaktusId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KaktusApi->readKaktusCaps: %s\n" % e)

extern crate KaktusApi;

pub fn main() {
    let kaktusId = kaktusId_example; // String

    let mut context = KaktusApi::Context::default();
    let result = client.readKaktusCaps(kaktusId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KaktusApi;

import java.io.File;
import java.util.*;

public class KaktusApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        KaktusApi apiInstance = new KaktusApi();
        String kaktusId = kaktusId_example; // String | The ID of the Kaktus computing node.
        Kaktus kaktus = ; // Kaktus | 

        try {
            Kaktus result = apiInstance.updateKaktus(kaktusId, kaktus);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KaktusApi#updateKaktus");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String kaktusId = new String(); // String | The ID of the Kaktus computing node.
final Kaktus kaktus = new Kaktus(); // Kaktus | 

try {
    final result = await api_instance.updateKaktus(kaktusId, kaktus);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->updateKaktus: $e\n');
}

import org.openapitools.client.api.KaktusApi;

public class KaktusApiExample {
    public static void main(String[] args) {
        KaktusApi apiInstance = new KaktusApi();
        String kaktusId = kaktusId_example; // String | The ID of the Kaktus computing node.
        Kaktus kaktus = ; // Kaktus | 

        try {
            Kaktus result = apiInstance.updateKaktus(kaktusId, kaktus);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KaktusApi#updateKaktus");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
KaktusApi *apiInstance = [[KaktusApi alloc] init];
String *kaktusId = kaktusId_example; // The ID of the Kaktus computing node. (default to null)
Kaktus *kaktus = ; // 

[apiInstance updateKaktusWith:kaktusId
    kaktus:kaktus
              completionHandler: ^(Kaktus output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KowabungaApiDocumentation = require('kowabunga_api_documentation');
var defaultClient = KowabungaApiDocumentation.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new KowabungaApiDocumentation.KaktusApi()
var kaktusId = kaktusId_example; // {String} The ID of the Kaktus computing node.
var kaktus = ; // {Kaktus} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateKaktus(kaktusId, kaktus, callback);

using System;
using System.Diagnostics;
using kowabunga.Api;
using kowabunga.Client;
using kowabunga.Model;

namespace Example
{
    public class updateKaktusExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new KaktusApi();
            var kaktusId = kaktusId_example;  // String | The ID of the Kaktus computing node. (default to null)
            var kaktus = new Kaktus(); // Kaktus | 

            try {
                Kaktus result = apiInstance.updateKaktus(kaktusId, kaktus);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KaktusApi.updateKaktus: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KaktusApi();
$kaktusId = kaktusId_example; // String | The ID of the Kaktus computing node.
$kaktus = ; // Kaktus | 

try {
    $result = $api_instance->updateKaktus($kaktusId, $kaktus);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling KaktusApi->updateKaktus: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KaktusApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KaktusApi->new();
my $kaktusId = kaktusId_example; # String | The ID of the Kaktus computing node.
my $kaktus = WWW::OPenAPIClient::Object::Kaktus->new(); # Kaktus | 

eval {
    my $result = $api_instance->updateKaktus(kaktusId => $kaktusId, kaktus => $kaktus);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KaktusApi->updateKaktus: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.KaktusApi()
kaktusId = kaktusId_example # String | The ID of the Kaktus computing node. (default to null)
kaktus =  # Kaktus | 

try:
    api_response = api_instance.update_kaktus(kaktusId, kaktus)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KaktusApi->updateKaktus: %s\n" % e)

extern crate KaktusApi;

pub fn main() {
    let kaktusId = kaktusId_example; // String
    let kaktus = ; // Kaktus

    let mut context = KaktusApi::Context::default();
    let result = client.updateKaktus(kaktusId, kaktus, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KawaiiApi;

import java.io.File;
import java.util.*;

public class KawaiiApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        KawaiiApi apiInstance = new KawaiiApi();
        String kawaiiId = kawaiiId_example; // String | The ID of the Kawaii.
        KawaiiIpSec kawaiiIpSec = ; // KawaiiIpSec | 

        try {
            KawaiiIpSec result = apiInstance.createKawaiiIpSec(kawaiiId, kawaiiIpSec);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KawaiiApi#createKawaiiIpSec");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String kawaiiId = new String(); // String | The ID of the Kawaii.
final KawaiiIpSec kawaiiIpSec = new KawaiiIpSec(); // KawaiiIpSec | 

try {
    final result = await api_instance.createKawaiiIpSec(kawaiiId, kawaiiIpSec);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->createKawaiiIpSec: $e\n');
}

import org.openapitools.client.api.KawaiiApi;

public class KawaiiApiExample {
    public static void main(String[] args) {
        KawaiiApi apiInstance = new KawaiiApi();
        String kawaiiId = kawaiiId_example; // String | The ID of the Kawaii.
        KawaiiIpSec kawaiiIpSec = ; // KawaiiIpSec | 

        try {
            KawaiiIpSec result = apiInstance.createKawaiiIpSec(kawaiiId, kawaiiIpSec);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KawaiiApi#createKawaiiIpSec");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
KawaiiApi *apiInstance = [[KawaiiApi alloc] init];
String *kawaiiId = kawaiiId_example; // The ID of the Kawaii. (default to null)
KawaiiIpSec *kawaiiIpSec = ; // 

[apiInstance createKawaiiIpSecWith:kawaiiId
    kawaiiIpSec:kawaiiIpSec
              completionHandler: ^(KawaiiIpSec output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KowabungaApiDocumentation = require('kowabunga_api_documentation');
var defaultClient = KowabungaApiDocumentation.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new KowabungaApiDocumentation.KawaiiApi()
var kawaiiId = kawaiiId_example; // {String} The ID of the Kawaii.
var kawaiiIpSec = ; // {KawaiiIpSec} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createKawaiiIpSec(kawaiiId, kawaiiIpSec, callback);

using System;
using System.Diagnostics;
using kowabunga.Api;
using kowabunga.Client;
using kowabunga.Model;

namespace Example
{
    public class createKawaiiIpSecExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new KawaiiApi();
            var kawaiiId = kawaiiId_example;  // String | The ID of the Kawaii. (default to null)
            var kawaiiIpSec = new KawaiiIpSec(); // KawaiiIpSec | 

            try {
                KawaiiIpSec result = apiInstance.createKawaiiIpSec(kawaiiId, kawaiiIpSec);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KawaiiApi.createKawaiiIpSec: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KawaiiApi();
$kawaiiId = kawaiiId_example; // String | The ID of the Kawaii.
$kawaiiIpSec = ; // KawaiiIpSec | 

try {
    $result = $api_instance->createKawaiiIpSec($kawaiiId, $kawaiiIpSec);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling KawaiiApi->createKawaiiIpSec: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KawaiiApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KawaiiApi->new();
my $kawaiiId = kawaiiId_example; # String | The ID of the Kawaii.
my $kawaiiIpSec = WWW::OPenAPIClient::Object::KawaiiIpSec->new(); # KawaiiIpSec | 

eval {
    my $result = $api_instance->createKawaiiIpSec(kawaiiId => $kawaiiId, kawaiiIpSec => $kawaiiIpSec);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KawaiiApi->createKawaiiIpSec: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.KawaiiApi()
kawaiiId = kawaiiId_example # String | The ID of the Kawaii. (default to null)
kawaiiIpSec =  # KawaiiIpSec | 

try:
    api_response = api_instance.create_kawaii_ip_sec(kawaiiId, kawaiiIpSec)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KawaiiApi->createKawaiiIpSec: %s\n" % e)

extern crate KawaiiApi;

pub fn main() {
    let kawaiiId = kawaiiId_example; // String
    let kawaiiIpSec = ; // KawaiiIpSec

    let mut context = KawaiiApi::Context::default();
    let result = client.createKawaiiIpSec(kawaiiId, kawaiiIpSec, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KawaiiApi;

import java.io.File;
import java.util.*;

public class KawaiiApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        KawaiiApi apiInstance = new KawaiiApi();
        String projectId = projectId_example; // String | The ID of the project.
        String regionId = regionId_example; // String | The ID of the region.
        Kawaii kawaii = ; // Kawaii | 

        try {
            Kawaii result = apiInstance.createProjectRegionKawaii(projectId, regionId, kawaii);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KawaiiApi#createProjectRegionKawaii");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String projectId = new String(); // String | The ID of the project.
final String regionId = new String(); // String | The ID of the region.
final Kawaii kawaii = new Kawaii(); // Kawaii | 

try {
    final result = await api_instance.createProjectRegionKawaii(projectId, regionId, kawaii);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->createProjectRegionKawaii: $e\n');
}

import org.openapitools.client.api.KawaiiApi;

public class KawaiiApiExample {
    public static void main(String[] args) {
        KawaiiApi apiInstance = new KawaiiApi();
        String projectId = projectId_example; // String | The ID of the project.
        String regionId = regionId_example; // String | The ID of the region.
        Kawaii kawaii = ; // Kawaii | 

        try {
            Kawaii result = apiInstance.createProjectRegionKawaii(projectId, regionId, kawaii);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KawaiiApi#createProjectRegionKawaii");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
KawaiiApi *apiInstance = [[KawaiiApi alloc] init];
String *projectId = projectId_example; // The ID of the project. (default to null)
String *regionId = regionId_example; // The ID of the region. (default to null)
Kawaii *kawaii = ; // 

[apiInstance createProjectRegionKawaiiWith:projectId
    regionId:regionId
    kawaii:kawaii
              completionHandler: ^(Kawaii output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KowabungaApiDocumentation = require('kowabunga_api_documentation');
var defaultClient = KowabungaApiDocumentation.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new KowabungaApiDocumentation.KawaiiApi()
var projectId = projectId_example; // {String} The ID of the project.
var regionId = regionId_example; // {String} The ID of the region.
var kawaii = ; // {Kawaii} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createProjectRegionKawaii(projectId, regionId, kawaii, callback);

using System;
using System.Diagnostics;
using kowabunga.Api;
using kowabunga.Client;
using kowabunga.Model;

namespace Example
{
    public class createProjectRegionKawaiiExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new KawaiiApi();
            var projectId = projectId_example;  // String | The ID of the project. (default to null)
            var regionId = regionId_example;  // String | The ID of the region. (default to null)
            var kawaii = new Kawaii(); // Kawaii | 

            try {
                Kawaii result = apiInstance.createProjectRegionKawaii(projectId, regionId, kawaii);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KawaiiApi.createProjectRegionKawaii: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KawaiiApi();
$projectId = projectId_example; // String | The ID of the project.
$regionId = regionId_example; // String | The ID of the region.
$kawaii = ; // Kawaii | 

try {
    $result = $api_instance->createProjectRegionKawaii($projectId, $regionId, $kawaii);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling KawaiiApi->createProjectRegionKawaii: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KawaiiApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KawaiiApi->new();
my $projectId = projectId_example; # String | The ID of the project.
my $regionId = regionId_example; # String | The ID of the region.
my $kawaii = WWW::OPenAPIClient::Object::Kawaii->new(); # Kawaii | 

eval {
    my $result = $api_instance->createProjectRegionKawaii(projectId => $projectId, regionId => $regionId, kawaii => $kawaii);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KawaiiApi->createProjectRegionKawaii: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.KawaiiApi()
projectId = projectId_example # String | The ID of the project. (default to null)
regionId = regionId_example # String | The ID of the region. (default to null)
kawaii =  # Kawaii | 

try:
    api_response = api_instance.create_project_region_kawaii(projectId, regionId, kawaii)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KawaiiApi->createProjectRegionKawaii: %s\n" % e)

extern crate KawaiiApi;

pub fn main() {
    let projectId = projectId_example; // String
    let regionId = regionId_example; // String
    let kawaii = ; // Kawaii

    let mut context = KawaiiApi::Context::default();
    let result = client.createProjectRegionKawaii(projectId, regionId, kawaii, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KawaiiApi;

import java.io.File;
import java.util.*;

public class KawaiiApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        KawaiiApi apiInstance = new KawaiiApi();
        String kawaiiId = kawaiiId_example; // String | The ID of the Kawaii.

        try {
            apiInstance.deleteKawaii(kawaiiId);
        } catch (ApiException e) {
            System.err.println("Exception when calling KawaiiApi#deleteKawaii");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String kawaiiId = new String(); // String | The ID of the Kawaii.

try {
    final result = await api_instance.deleteKawaii(kawaiiId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteKawaii: $e\n');
}

import org.openapitools.client.api.KawaiiApi;

public class KawaiiApiExample {
    public static void main(String[] args) {
        KawaiiApi apiInstance = new KawaiiApi();
        String kawaiiId = kawaiiId_example; // String | The ID of the Kawaii.

        try {
            apiInstance.deleteKawaii(kawaiiId);
        } catch (ApiException e) {
            System.err.println("Exception when calling KawaiiApi#deleteKawaii");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
KawaiiApi *apiInstance = [[KawaiiApi alloc] init];
String *kawaiiId = kawaiiId_example; // The ID of the Kawaii. (default to null)

[apiInstance deleteKawaiiWith:kawaiiId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KowabungaApiDocumentation = require('kowabunga_api_documentation');
var defaultClient = KowabungaApiDocumentation.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new KowabungaApiDocumentation.KawaiiApi()
var kawaiiId = kawaiiId_example; // {String} The ID of the Kawaii.

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteKawaii(kawaiiId, callback);

using System;
using System.Diagnostics;
using kowabunga.Api;
using kowabunga.Client;
using kowabunga.Model;

namespace Example
{
    public class deleteKawaiiExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new KawaiiApi();
            var kawaiiId = kawaiiId_example;  // String | The ID of the Kawaii. (default to null)

            try {
                apiInstance.deleteKawaii(kawaiiId);
            } catch (Exception e) {
                Debug.Print("Exception when calling KawaiiApi.deleteKawaii: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KawaiiApi();
$kawaiiId = kawaiiId_example; // String | The ID of the Kawaii.

try {
    $api_instance->deleteKawaii($kawaiiId);
} catch (Exception $e) {
    echo 'Exception when calling KawaiiApi->deleteKawaii: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KawaiiApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KawaiiApi->new();
my $kawaiiId = kawaiiId_example; # String | The ID of the Kawaii.

eval {
    $api_instance->deleteKawaii(kawaiiId => $kawaiiId);
};
if ($@) {
    warn "Exception when calling KawaiiApi->deleteKawaii: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.KawaiiApi()
kawaiiId = kawaiiId_example # String | The ID of the Kawaii. (default to null)

try:
    api_instance.delete_kawaii(kawaiiId)
except ApiException as e:
    print("Exception when calling KawaiiApi->deleteKawaii: %s\n" % e)

extern crate KawaiiApi;

pub fn main() {
    let kawaiiId = kawaiiId_example; // String

    let mut context = KawaiiApi::Context::default();
    let result = client.deleteKawaii(kawaiiId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KawaiiApi;

import java.io.File;
import java.util.*;

public class KawaiiApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        KawaiiApi apiInstance = new KawaiiApi();
        String kawaiiId = kawaiiId_example; // String | The ID of the Kawaii.
        String kawaiiIpSecId = kawaiiIpSecId_example; // String | The ID of the Kawaii IPsec connection.

        try {
            apiInstance.deleteKawaiiIpSec(kawaiiId, kawaiiIpSecId);
        } catch (ApiException e) {
            System.err.println("Exception when calling KawaiiApi#deleteKawaiiIpSec");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String kawaiiId = new String(); // String | The ID of the Kawaii.
final String kawaiiIpSecId = new String(); // String | The ID of the Kawaii IPsec connection.

try {
    final result = await api_instance.deleteKawaiiIpSec(kawaiiId, kawaiiIpSecId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteKawaiiIpSec: $e\n');
}

import org.openapitools.client.api.KawaiiApi;

public class KawaiiApiExample {
    public static void main(String[] args) {
        KawaiiApi apiInstance = new KawaiiApi();
        String kawaiiId = kawaiiId_example; // String | The ID of the Kawaii.
        String kawaiiIpSecId = kawaiiIpSecId_example; // String | The ID of the Kawaii IPsec connection.

        try {
            apiInstance.deleteKawaiiIpSec(kawaiiId, kawaiiIpSecId);
        } catch (ApiException e) {
            System.err.println("Exception when calling KawaiiApi#deleteKawaiiIpSec");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
KawaiiApi *apiInstance = [[KawaiiApi alloc] init];
String *kawaiiId = kawaiiId_example; // The ID of the Kawaii. (default to null)
String *kawaiiIpSecId = kawaiiIpSecId_example; // The ID of the Kawaii IPsec connection. (default to null)

[apiInstance deleteKawaiiIpSecWith:kawaiiId
    kawaiiIpSecId:kawaiiIpSecId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KowabungaApiDocumentation = require('kowabunga_api_documentation');
var defaultClient = KowabungaApiDocumentation.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new KowabungaApiDocumentation.KawaiiApi()
var kawaiiId = kawaiiId_example; // {String} The ID of the Kawaii.
var kawaiiIpSecId = kawaiiIpSecId_example; // {String} The ID of the Kawaii IPsec connection.

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteKawaiiIpSec(kawaiiId, kawaiiIpSecId, callback);

using System;
using System.Diagnostics;
using kowabunga.Api;
using kowabunga.Client;
using kowabunga.Model;

namespace Example
{
    public class deleteKawaiiIpSecExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new KawaiiApi();
            var kawaiiId = kawaiiId_example;  // String | The ID of the Kawaii. (default to null)
            var kawaiiIpSecId = kawaiiIpSecId_example;  // String | The ID of the Kawaii IPsec connection. (default to null)

            try {
                apiInstance.deleteKawaiiIpSec(kawaiiId, kawaiiIpSecId);
            } catch (Exception e) {
                Debug.Print("Exception when calling KawaiiApi.deleteKawaiiIpSec: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KawaiiApi();
$kawaiiId = kawaiiId_example; // String | The ID of the Kawaii.
$kawaiiIpSecId = kawaiiIpSecId_example; // String | The ID of the Kawaii IPsec connection.

try {
    $api_instance->deleteKawaiiIpSec($kawaiiId, $kawaiiIpSecId);
} catch (Exception $e) {
    echo 'Exception when calling KawaiiApi->deleteKawaiiIpSec: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KawaiiApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KawaiiApi->new();
my $kawaiiId = kawaiiId_example; # String | The ID of the Kawaii.
my $kawaiiIpSecId = kawaiiIpSecId_example; # String | The ID of the Kawaii IPsec connection.

eval {
    $api_instance->deleteKawaiiIpSec(kawaiiId => $kawaiiId, kawaiiIpSecId => $kawaiiIpSecId);
};
if ($@) {
    warn "Exception when calling KawaiiApi->deleteKawaiiIpSec: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.KawaiiApi()
kawaiiId = kawaiiId_example # String | The ID of the Kawaii. (default to null)
kawaiiIpSecId = kawaiiIpSecId_example # String | The ID of the Kawaii IPsec connection. (default to null)

try:
    api_instance.delete_kawaii_ip_sec(kawaiiId, kawaiiIpSecId)
except ApiException as e:
    print("Exception when calling KawaiiApi->deleteKawaiiIpSec: %s\n" % e)

extern crate KawaiiApi;

pub fn main() {
    let kawaiiId = kawaiiId_example; // String
    let kawaiiIpSecId = kawaiiIpSecId_example; // String

    let mut context = KawaiiApi::Context::default();
    let result = client.deleteKawaiiIpSec(kawaiiId, kawaiiIpSecId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KawaiiApi;

import java.io.File;
import java.util.*;

public class KawaiiApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        KawaiiApi apiInstance = new KawaiiApi();
        String kawaiiId = kawaiiId_example; // String | The ID of the Kawaii.

        try {
            array['String'] result = apiInstance.listKawaiiIpSecs(kawaiiId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KawaiiApi#listKawaiiIpSecs");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String kawaiiId = new String(); // String | The ID of the Kawaii.

try {
    final result = await api_instance.listKawaiiIpSecs(kawaiiId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->listKawaiiIpSecs: $e\n');
}

import org.openapitools.client.api.KawaiiApi;

public class KawaiiApiExample {
    public static void main(String[] args) {
        KawaiiApi apiInstance = new KawaiiApi();
        String kawaiiId = kawaiiId_example; // String | The ID of the Kawaii.

        try {
            array['String'] result = apiInstance.listKawaiiIpSecs(kawaiiId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KawaiiApi#listKawaiiIpSecs");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
KawaiiApi *apiInstance = [[KawaiiApi alloc] init];
String *kawaiiId = kawaiiId_example; // The ID of the Kawaii. (default to null)

[apiInstance listKawaiiIpSecsWith:kawaiiId
              completionHandler: ^(array['String'] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KowabungaApiDocumentation = require('kowabunga_api_documentation');
var defaultClient = KowabungaApiDocumentation.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new KowabungaApiDocumentation.KawaiiApi()
var kawaiiId = kawaiiId_example; // {String} The ID of the Kawaii.

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listKawaiiIpSecs(kawaiiId, callback);

using System;
using System.Diagnostics;
using kowabunga.Api;
using kowabunga.Client;
using kowabunga.Model;

namespace Example
{
    public class listKawaiiIpSecsExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new KawaiiApi();
            var kawaiiId = kawaiiId_example;  // String | The ID of the Kawaii. (default to null)

            try {
                array['String'] result = apiInstance.listKawaiiIpSecs(kawaiiId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KawaiiApi.listKawaiiIpSecs: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KawaiiApi();
$kawaiiId = kawaiiId_example; // String | The ID of the Kawaii.

try {
    $result = $api_instance->listKawaiiIpSecs($kawaiiId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling KawaiiApi->listKawaiiIpSecs: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KawaiiApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KawaiiApi->new();
my $kawaiiId = kawaiiId_example; # String | The ID of the Kawaii.

eval {
    my $result = $api_instance->listKawaiiIpSecs(kawaiiId => $kawaiiId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KawaiiApi->listKawaiiIpSecs: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.KawaiiApi()
kawaiiId = kawaiiId_example # String | The ID of the Kawaii. (default to null)

try:
    api_response = api_instance.list_kawaii_ip_secs(kawaiiId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KawaiiApi->listKawaiiIpSecs: %s\n" % e)

extern crate KawaiiApi;

pub fn main() {
    let kawaiiId = kawaiiId_example; // String

    let mut context = KawaiiApi::Context::default();
    let result = client.listKawaiiIpSecs(kawaiiId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KawaiiApi;

import java.io.File;
import java.util.*;

public class KawaiiApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        KawaiiApi apiInstance = new KawaiiApi();

        try {
            array['String'] result = apiInstance.listKawaiis();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KawaiiApi#listKawaiis");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.listKawaiis();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->listKawaiis: $e\n');
}

import org.openapitools.client.api.KawaiiApi;

public class KawaiiApiExample {
    public static void main(String[] args) {
        KawaiiApi apiInstance = new KawaiiApi();

        try {
            array['String'] result = apiInstance.listKawaiis();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KawaiiApi#listKawaiis");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
KawaiiApi *apiInstance = [[KawaiiApi alloc] init];

[apiInstance listKawaiisWithCompletionHandler: 
              ^(array['String'] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KowabungaApiDocumentation = require('kowabunga_api_documentation');
var defaultClient = KowabungaApiDocumentation.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new KowabungaApiDocumentation.KawaiiApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listKawaiis(callback);

using System;
using System.Diagnostics;
using kowabunga.Api;
using kowabunga.Client;
using kowabunga.Model;

namespace Example
{
    public class listKawaiisExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new KawaiiApi();

            try {
                array['String'] result = apiInstance.listKawaiis();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KawaiiApi.listKawaiis: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KawaiiApi();

try {
    $result = $api_instance->listKawaiis();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling KawaiiApi->listKawaiis: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KawaiiApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KawaiiApi->new();

eval {
    my $result = $api_instance->listKawaiis();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KawaiiApi->listKawaiis: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.KawaiiApi()

try:
    api_response = api_instance.list_kawaiis()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KawaiiApi->listKawaiis: %s\n" % e)

extern crate KawaiiApi;

pub fn main() {

    let mut context = KawaiiApi::Context::default();
    let result = client.listKawaiis(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KawaiiApi;

import java.io.File;
import java.util.*;

public class KawaiiApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        KawaiiApi apiInstance = new KawaiiApi();
        String projectId = projectId_example; // String | The ID of the project.
        String regionId = regionId_example; // String | The ID of the region.

        try {
            array['String'] result = apiInstance.listProjectRegionKawaiis(projectId, regionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KawaiiApi#listProjectRegionKawaiis");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String projectId = new String(); // String | The ID of the project.
final String regionId = new String(); // String | The ID of the region.

try {
    final result = await api_instance.listProjectRegionKawaiis(projectId, regionId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->listProjectRegionKawaiis: $e\n');
}

import org.openapitools.client.api.KawaiiApi;

public class KawaiiApiExample {
    public static void main(String[] args) {
        KawaiiApi apiInstance = new KawaiiApi();
        String projectId = projectId_example; // String | The ID of the project.
        String regionId = regionId_example; // String | The ID of the region.

        try {
            array['String'] result = apiInstance.listProjectRegionKawaiis(projectId, regionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KawaiiApi#listProjectRegionKawaiis");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
KawaiiApi *apiInstance = [[KawaiiApi alloc] init];
String *projectId = projectId_example; // The ID of the project. (default to null)
String *regionId = regionId_example; // The ID of the region. (default to null)

[apiInstance listProjectRegionKawaiisWith:projectId
    regionId:regionId
              completionHandler: ^(array['String'] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KowabungaApiDocumentation = require('kowabunga_api_documentation');
var defaultClient = KowabungaApiDocumentation.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new KowabungaApiDocumentation.KawaiiApi()
var projectId = projectId_example; // {String} The ID of the project.
var regionId = regionId_example; // {String} The ID of the region.

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listProjectRegionKawaiis(projectId, regionId, callback);

using System;
using System.Diagnostics;
using kowabunga.Api;
using kowabunga.Client;
using kowabunga.Model;

namespace Example
{
    public class listProjectRegionKawaiisExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new KawaiiApi();
            var projectId = projectId_example;  // String | The ID of the project. (default to null)
            var regionId = regionId_example;  // String | The ID of the region. (default to null)

            try {
                array['String'] result = apiInstance.listProjectRegionKawaiis(projectId, regionId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KawaiiApi.listProjectRegionKawaiis: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KawaiiApi();
$projectId = projectId_example; // String | The ID of the project.
$regionId = regionId_example; // String | The ID of the region.

try {
    $result = $api_instance->listProjectRegionKawaiis($projectId, $regionId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling KawaiiApi->listProjectRegionKawaiis: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KawaiiApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KawaiiApi->new();
my $projectId = projectId_example; # String | The ID of the project.
my $regionId = regionId_example; # String | The ID of the region.

eval {
    my $result = $api_instance->listProjectRegionKawaiis(projectId => $projectId, regionId => $regionId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KawaiiApi->listProjectRegionKawaiis: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.KawaiiApi()
projectId = projectId_example # String | The ID of the project. (default to null)
regionId = regionId_example # String | The ID of the region. (default to null)

try:
    api_response = api_instance.list_project_region_kawaiis(projectId, regionId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KawaiiApi->listProjectRegionKawaiis: %s\n" % e)

extern crate KawaiiApi;

pub fn main() {
    let projectId = projectId_example; // String
    let regionId = regionId_example; // String

    let mut context = KawaiiApi::Context::default();
    let result = client.listProjectRegionKawaiis(projectId, regionId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KawaiiApi;

import java.io.File;
import java.util.*;

public class KawaiiApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        KawaiiApi apiInstance = new KawaiiApi();
        String kawaiiId = kawaiiId_example; // String | The ID of the Kawaii.

        try {
            Kawaii result = apiInstance.readKawaii(kawaiiId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KawaiiApi#readKawaii");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String kawaiiId = new String(); // String | The ID of the Kawaii.

try {
    final result = await api_instance.readKawaii(kawaiiId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->readKawaii: $e\n');
}

import org.openapitools.client.api.KawaiiApi;

public class KawaiiApiExample {
    public static void main(String[] args) {
        KawaiiApi apiInstance = new KawaiiApi();
        String kawaiiId = kawaiiId_example; // String | The ID of the Kawaii.

        try {
            Kawaii result = apiInstance.readKawaii(kawaiiId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KawaiiApi#readKawaii");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
KawaiiApi *apiInstance = [[KawaiiApi alloc] init];
String *kawaiiId = kawaiiId_example; // The ID of the Kawaii. (default to null)

[apiInstance readKawaiiWith:kawaiiId
              completionHandler: ^(Kawaii output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KowabungaApiDocumentation = require('kowabunga_api_documentation');
var defaultClient = KowabungaApiDocumentation.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new KowabungaApiDocumentation.KawaiiApi()
var kawaiiId = kawaiiId_example; // {String} The ID of the Kawaii.

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.readKawaii(kawaiiId, callback);

using System;
using System.Diagnostics;
using kowabunga.Api;
using kowabunga.Client;
using kowabunga.Model;

namespace Example
{
    public class readKawaiiExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new KawaiiApi();
            var kawaiiId = kawaiiId_example;  // String | The ID of the Kawaii. (default to null)

            try {
                Kawaii result = apiInstance.readKawaii(kawaiiId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KawaiiApi.readKawaii: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KawaiiApi();
$kawaiiId = kawaiiId_example; // String | The ID of the Kawaii.

try {
    $result = $api_instance->readKawaii($kawaiiId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling KawaiiApi->readKawaii: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KawaiiApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KawaiiApi->new();
my $kawaiiId = kawaiiId_example; # String | The ID of the Kawaii.

eval {
    my $result = $api_instance->readKawaii(kawaiiId => $kawaiiId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KawaiiApi->readKawaii: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.KawaiiApi()
kawaiiId = kawaiiId_example # String | The ID of the Kawaii. (default to null)

try:
    api_response = api_instance.read_kawaii(kawaiiId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KawaiiApi->readKawaii: %s\n" % e)

extern crate KawaiiApi;

pub fn main() {
    let kawaiiId = kawaiiId_example; // String

    let mut context = KawaiiApi::Context::default();
    let result = client.readKawaii(kawaiiId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KawaiiApi;

import java.io.File;
import java.util.*;

public class KawaiiApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        KawaiiApi apiInstance = new KawaiiApi();
        String kawaiiId = kawaiiId_example; // String | The ID of the Kawaii.
        String kawaiiIpSecId = kawaiiIpSecId_example; // String | The ID of the Kawaii IPsec connection.

        try {
            KawaiiIpSec result = apiInstance.readKawaiiIpSec(kawaiiId, kawaiiIpSecId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KawaiiApi#readKawaiiIpSec");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String kawaiiId = new String(); // String | The ID of the Kawaii.
final String kawaiiIpSecId = new String(); // String | The ID of the Kawaii IPsec connection.

try {
    final result = await api_instance.readKawaiiIpSec(kawaiiId, kawaiiIpSecId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->readKawaiiIpSec: $e\n');
}

import org.openapitools.client.api.KawaiiApi;

public class KawaiiApiExample {
    public static void main(String[] args) {
        KawaiiApi apiInstance = new KawaiiApi();
        String kawaiiId = kawaiiId_example; // String | The ID of the Kawaii.
        String kawaiiIpSecId = kawaiiIpSecId_example; // String | The ID of the Kawaii IPsec connection.

        try {
            KawaiiIpSec result = apiInstance.readKawaiiIpSec(kawaiiId, kawaiiIpSecId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KawaiiApi#readKawaiiIpSec");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
KawaiiApi *apiInstance = [[KawaiiApi alloc] init];
String *kawaiiId = kawaiiId_example; // The ID of the Kawaii. (default to null)
String *kawaiiIpSecId = kawaiiIpSecId_example; // The ID of the Kawaii IPsec connection. (default to null)

[apiInstance readKawaiiIpSecWith:kawaiiId
    kawaiiIpSecId:kawaiiIpSecId
              completionHandler: ^(KawaiiIpSec output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KowabungaApiDocumentation = require('kowabunga_api_documentation');
var defaultClient = KowabungaApiDocumentation.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new KowabungaApiDocumentation.KawaiiApi()
var kawaiiId = kawaiiId_example; // {String} The ID of the Kawaii.
var kawaiiIpSecId = kawaiiIpSecId_example; // {String} The ID of the Kawaii IPsec connection.

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.readKawaiiIpSec(kawaiiId, kawaiiIpSecId, callback);

using System;
using System.Diagnostics;
using kowabunga.Api;
using kowabunga.Client;
using kowabunga.Model;

namespace Example
{
    public class readKawaiiIpSecExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new KawaiiApi();
            var kawaiiId = kawaiiId_example;  // String | The ID of the Kawaii. (default to null)
            var kawaiiIpSecId = kawaiiIpSecId_example;  // String | The ID of the Kawaii IPsec connection. (default to null)

            try {
                KawaiiIpSec result = apiInstance.readKawaiiIpSec(kawaiiId, kawaiiIpSecId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KawaiiApi.readKawaiiIpSec: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KawaiiApi();
$kawaiiId = kawaiiId_example; // String | The ID of the Kawaii.
$kawaiiIpSecId = kawaiiIpSecId_example; // String | The ID of the Kawaii IPsec connection.

try {
    $result = $api_instance->readKawaiiIpSec($kawaiiId, $kawaiiIpSecId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling KawaiiApi->readKawaiiIpSec: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KawaiiApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KawaiiApi->new();
my $kawaiiId = kawaiiId_example; # String | The ID of the Kawaii.
my $kawaiiIpSecId = kawaiiIpSecId_example; # String | The ID of the Kawaii IPsec connection.

eval {
    my $result = $api_instance->readKawaiiIpSec(kawaiiId => $kawaiiId, kawaiiIpSecId => $kawaiiIpSecId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KawaiiApi->readKawaiiIpSec: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.KawaiiApi()
kawaiiId = kawaiiId_example # String | The ID of the Kawaii. (default to null)
kawaiiIpSecId = kawaiiIpSecId_example # String | The ID of the Kawaii IPsec connection. (default to null)

try:
    api_response = api_instance.read_kawaii_ip_sec(kawaiiId, kawaiiIpSecId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KawaiiApi->readKawaiiIpSec: %s\n" % e)

extern crate KawaiiApi;

pub fn main() {
    let kawaiiId = kawaiiId_example; // String
    let kawaiiIpSecId = kawaiiIpSecId_example; // String

    let mut context = KawaiiApi::Context::default();
    let result = client.readKawaiiIpSec(kawaiiId, kawaiiIpSecId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KawaiiApi;

import java.io.File;
import java.util.*;

public class KawaiiApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        KawaiiApi apiInstance = new KawaiiApi();
        String kawaiiId = kawaiiId_example; // String | The ID of the Kawaii.
        Kawaii kawaii = ; // Kawaii | 

        try {
            Kawaii result = apiInstance.updateKawaii(kawaiiId, kawaii);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KawaiiApi#updateKawaii");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String kawaiiId = new String(); // String | The ID of the Kawaii.
final Kawaii kawaii = new Kawaii(); // Kawaii | 

try {
    final result = await api_instance.updateKawaii(kawaiiId, kawaii);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->updateKawaii: $e\n');
}

import org.openapitools.client.api.KawaiiApi;

public class KawaiiApiExample {
    public static void main(String[] args) {
        KawaiiApi apiInstance = new KawaiiApi();
        String kawaiiId = kawaiiId_example; // String | The ID of the Kawaii.
        Kawaii kawaii = ; // Kawaii | 

        try {
            Kawaii result = apiInstance.updateKawaii(kawaiiId, kawaii);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KawaiiApi#updateKawaii");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
KawaiiApi *apiInstance = [[KawaiiApi alloc] init];
String *kawaiiId = kawaiiId_example; // The ID of the Kawaii. (default to null)
Kawaii *kawaii = ; // 

[apiInstance updateKawaiiWith:kawaiiId
    kawaii:kawaii
              completionHandler: ^(Kawaii output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KowabungaApiDocumentation = require('kowabunga_api_documentation');
var defaultClient = KowabungaApiDocumentation.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new KowabungaApiDocumentation.KawaiiApi()
var kawaiiId = kawaiiId_example; // {String} The ID of the Kawaii.
var kawaii = ; // {Kawaii} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateKawaii(kawaiiId, kawaii, callback);

using System;
using System.Diagnostics;
using kowabunga.Api;
using kowabunga.Client;
using kowabunga.Model;

namespace Example
{
    public class updateKawaiiExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new KawaiiApi();
            var kawaiiId = kawaiiId_example;  // String | The ID of the Kawaii. (default to null)
            var kawaii = new Kawaii(); // Kawaii | 

            try {
                Kawaii result = apiInstance.updateKawaii(kawaiiId, kawaii);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KawaiiApi.updateKawaii: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KawaiiApi();
$kawaiiId = kawaiiId_example; // String | The ID of the Kawaii.
$kawaii = ; // Kawaii | 

try {
    $result = $api_instance->updateKawaii($kawaiiId, $kawaii);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling KawaiiApi->updateKawaii: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KawaiiApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KawaiiApi->new();
my $kawaiiId = kawaiiId_example; # String | The ID of the Kawaii.
my $kawaii = WWW::OPenAPIClient::Object::Kawaii->new(); # Kawaii | 

eval {
    my $result = $api_instance->updateKawaii(kawaiiId => $kawaiiId, kawaii => $kawaii);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KawaiiApi->updateKawaii: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.KawaiiApi()
kawaiiId = kawaiiId_example # String | The ID of the Kawaii. (default to null)
kawaii =  # Kawaii | 

try:
    api_response = api_instance.update_kawaii(kawaiiId, kawaii)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KawaiiApi->updateKawaii: %s\n" % e)

extern crate KawaiiApi;

pub fn main() {
    let kawaiiId = kawaiiId_example; // String
    let kawaii = ; // Kawaii

    let mut context = KawaiiApi::Context::default();
    let result = client.updateKawaii(kawaiiId, kawaii, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KawaiiApi;

import java.io.File;
import java.util.*;

public class KawaiiApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        KawaiiApi apiInstance = new KawaiiApi();
        String kawaiiId = kawaiiId_example; // String | The ID of the Kawaii.
        String kawaiiIpSecId = kawaiiIpSecId_example; // String | The ID of the Kawaii IPsec connection.
        KawaiiIpSec kawaiiIpSec = ; // KawaiiIpSec | 

        try {
            KawaiiIpSec result = apiInstance.updateKawaiiIpSec(kawaiiId, kawaiiIpSecId, kawaiiIpSec);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KawaiiApi#updateKawaiiIpSec");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String kawaiiId = new String(); // String | The ID of the Kawaii.
final String kawaiiIpSecId = new String(); // String | The ID of the Kawaii IPsec connection.
final KawaiiIpSec kawaiiIpSec = new KawaiiIpSec(); // KawaiiIpSec | 

try {
    final result = await api_instance.updateKawaiiIpSec(kawaiiId, kawaiiIpSecId, kawaiiIpSec);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->updateKawaiiIpSec: $e\n');
}

import org.openapitools.client.api.KawaiiApi;

public class KawaiiApiExample {
    public static void main(String[] args) {
        KawaiiApi apiInstance = new KawaiiApi();
        String kawaiiId = kawaiiId_example; // String | The ID of the Kawaii.
        String kawaiiIpSecId = kawaiiIpSecId_example; // String | The ID of the Kawaii IPsec connection.
        KawaiiIpSec kawaiiIpSec = ; // KawaiiIpSec | 

        try {
            KawaiiIpSec result = apiInstance.updateKawaiiIpSec(kawaiiId, kawaiiIpSecId, kawaiiIpSec);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KawaiiApi#updateKawaiiIpSec");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
KawaiiApi *apiInstance = [[KawaiiApi alloc] init];
String *kawaiiId = kawaiiId_example; // The ID of the Kawaii. (default to null)
String *kawaiiIpSecId = kawaiiIpSecId_example; // The ID of the Kawaii IPsec connection. (default to null)
KawaiiIpSec *kawaiiIpSec = ; // 

[apiInstance updateKawaiiIpSecWith:kawaiiId
    kawaiiIpSecId:kawaiiIpSecId
    kawaiiIpSec:kawaiiIpSec
              completionHandler: ^(KawaiiIpSec output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KowabungaApiDocumentation = require('kowabunga_api_documentation');
var defaultClient = KowabungaApiDocumentation.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new KowabungaApiDocumentation.KawaiiApi()
var kawaiiId = kawaiiId_example; // {String} The ID of the Kawaii.
var kawaiiIpSecId = kawaiiIpSecId_example; // {String} The ID of the Kawaii IPsec connection.
var kawaiiIpSec = ; // {KawaiiIpSec} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateKawaiiIpSec(kawaiiId, kawaiiIpSecId, kawaiiIpSec, callback);

using System;
using System.Diagnostics;
using kowabunga.Api;
using kowabunga.Client;
using kowabunga.Model;

namespace Example
{
    public class updateKawaiiIpSecExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new KawaiiApi();
            var kawaiiId = kawaiiId_example;  // String | The ID of the Kawaii. (default to null)
            var kawaiiIpSecId = kawaiiIpSecId_example;  // String | The ID of the Kawaii IPsec connection. (default to null)
            var kawaiiIpSec = new KawaiiIpSec(); // KawaiiIpSec | 

            try {
                KawaiiIpSec result = apiInstance.updateKawaiiIpSec(kawaiiId, kawaiiIpSecId, kawaiiIpSec);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KawaiiApi.updateKawaiiIpSec: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KawaiiApi();
$kawaiiId = kawaiiId_example; // String | The ID of the Kawaii.
$kawaiiIpSecId = kawaiiIpSecId_example; // String | The ID of the Kawaii IPsec connection.
$kawaiiIpSec = ; // KawaiiIpSec | 

try {
    $result = $api_instance->updateKawaiiIpSec($kawaiiId, $kawaiiIpSecId, $kawaiiIpSec);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling KawaiiApi->updateKawaiiIpSec: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KawaiiApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KawaiiApi->new();
my $kawaiiId = kawaiiId_example; # String | The ID of the Kawaii.
my $kawaiiIpSecId = kawaiiIpSecId_example; # String | The ID of the Kawaii IPsec connection.
my $kawaiiIpSec = WWW::OPenAPIClient::Object::KawaiiIpSec->new(); # KawaiiIpSec | 

eval {
    my $result = $api_instance->updateKawaiiIpSec(kawaiiId => $kawaiiId, kawaiiIpSecId => $kawaiiIpSecId, kawaiiIpSec => $kawaiiIpSec);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KawaiiApi->updateKawaiiIpSec: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.KawaiiApi()
kawaiiId = kawaiiId_example # String | The ID of the Kawaii. (default to null)
kawaiiIpSecId = kawaiiIpSecId_example # String | The ID of the Kawaii IPsec connection. (default to null)
kawaiiIpSec =  # KawaiiIpSec | 

try:
    api_response = api_instance.update_kawaii_ip_sec(kawaiiId, kawaiiIpSecId, kawaiiIpSec)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KawaiiApi->updateKawaiiIpSec: %s\n" % e)

extern crate KawaiiApi;

pub fn main() {
    let kawaiiId = kawaiiId_example; // String
    let kawaiiIpSecId = kawaiiIpSecId_example; // String
    let kawaiiIpSec = ; // KawaiiIpSec

    let mut context = KawaiiApi::Context::default();
    let result = client.updateKawaiiIpSec(kawaiiId, kawaiiIpSecId, kawaiiIpSec, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KawaiiIpsecApi;

import java.io.File;
import java.util.*;

public class KawaiiIpsecApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        KawaiiIpsecApi apiInstance = new KawaiiIpsecApi();
        String kawaiiId = kawaiiId_example; // String | The ID of the Kawaii.
        KawaiiIpSec kawaiiIpSec = ; // KawaiiIpSec | 

        try {
            KawaiiIpSec result = apiInstance.createKawaiiIpSec(kawaiiId, kawaiiIpSec);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KawaiiIpsecApi#createKawaiiIpSec");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String kawaiiId = new String(); // String | The ID of the Kawaii.
final KawaiiIpSec kawaiiIpSec = new KawaiiIpSec(); // KawaiiIpSec | 

try {
    final result = await api_instance.createKawaiiIpSec(kawaiiId, kawaiiIpSec);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->createKawaiiIpSec: $e\n');
}

import org.openapitools.client.api.KawaiiIpsecApi;

public class KawaiiIpsecApiExample {
    public static void main(String[] args) {
        KawaiiIpsecApi apiInstance = new KawaiiIpsecApi();
        String kawaiiId = kawaiiId_example; // String | The ID of the Kawaii.
        KawaiiIpSec kawaiiIpSec = ; // KawaiiIpSec | 

        try {
            KawaiiIpSec result = apiInstance.createKawaiiIpSec(kawaiiId, kawaiiIpSec);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KawaiiIpsecApi#createKawaiiIpSec");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
KawaiiIpsecApi *apiInstance = [[KawaiiIpsecApi alloc] init];
String *kawaiiId = kawaiiId_example; // The ID of the Kawaii. (default to null)
KawaiiIpSec *kawaiiIpSec = ; // 

[apiInstance createKawaiiIpSecWith:kawaiiId
    kawaiiIpSec:kawaiiIpSec
              completionHandler: ^(KawaiiIpSec output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KowabungaApiDocumentation = require('kowabunga_api_documentation');
var defaultClient = KowabungaApiDocumentation.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new KowabungaApiDocumentation.KawaiiIpsecApi()
var kawaiiId = kawaiiId_example; // {String} The ID of the Kawaii.
var kawaiiIpSec = ; // {KawaiiIpSec} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createKawaiiIpSec(kawaiiId, kawaiiIpSec, callback);

using System;
using System.Diagnostics;
using kowabunga.Api;
using kowabunga.Client;
using kowabunga.Model;

namespace Example
{
    public class createKawaiiIpSecExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new KawaiiIpsecApi();
            var kawaiiId = kawaiiId_example;  // String | The ID of the Kawaii. (default to null)
            var kawaiiIpSec = new KawaiiIpSec(); // KawaiiIpSec | 

            try {
                KawaiiIpSec result = apiInstance.createKawaiiIpSec(kawaiiId, kawaiiIpSec);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KawaiiIpsecApi.createKawaiiIpSec: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KawaiiIpsecApi();
$kawaiiId = kawaiiId_example; // String | The ID of the Kawaii.
$kawaiiIpSec = ; // KawaiiIpSec | 

try {
    $result = $api_instance->createKawaiiIpSec($kawaiiId, $kawaiiIpSec);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling KawaiiIpsecApi->createKawaiiIpSec: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KawaiiIpsecApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KawaiiIpsecApi->new();
my $kawaiiId = kawaiiId_example; # String | The ID of the Kawaii.
my $kawaiiIpSec = WWW::OPenAPIClient::Object::KawaiiIpSec->new(); # KawaiiIpSec | 

eval {
    my $result = $api_instance->createKawaiiIpSec(kawaiiId => $kawaiiId, kawaiiIpSec => $kawaiiIpSec);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KawaiiIpsecApi->createKawaiiIpSec: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.KawaiiIpsecApi()
kawaiiId = kawaiiId_example # String | The ID of the Kawaii. (default to null)
kawaiiIpSec =  # KawaiiIpSec | 

try:
    api_response = api_instance.create_kawaii_ip_sec(kawaiiId, kawaiiIpSec)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KawaiiIpsecApi->createKawaiiIpSec: %s\n" % e)

extern crate KawaiiIpsecApi;

pub fn main() {
    let kawaiiId = kawaiiId_example; // String
    let kawaiiIpSec = ; // KawaiiIpSec

    let mut context = KawaiiIpsecApi::Context::default();
    let result = client.createKawaiiIpSec(kawaiiId, kawaiiIpSec, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KawaiiIpsecApi;

import java.io.File;
import java.util.*;

public class KawaiiIpsecApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        KawaiiIpsecApi apiInstance = new KawaiiIpsecApi();
        String kawaiiId = kawaiiId_example; // String | The ID of the Kawaii.
        String kawaiiIpSecId = kawaiiIpSecId_example; // String | The ID of the Kawaii IPsec connection.

        try {
            apiInstance.deleteKawaiiIpSec(kawaiiId, kawaiiIpSecId);
        } catch (ApiException e) {
            System.err.println("Exception when calling KawaiiIpsecApi#deleteKawaiiIpSec");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String kawaiiId = new String(); // String | The ID of the Kawaii.
final String kawaiiIpSecId = new String(); // String | The ID of the Kawaii IPsec connection.

try {
    final result = await api_instance.deleteKawaiiIpSec(kawaiiId, kawaiiIpSecId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteKawaiiIpSec: $e\n');
}

import org.openapitools.client.api.KawaiiIpsecApi;

public class KawaiiIpsecApiExample {
    public static void main(String[] args) {
        KawaiiIpsecApi apiInstance = new KawaiiIpsecApi();
        String kawaiiId = kawaiiId_example; // String | The ID of the Kawaii.
        String kawaiiIpSecId = kawaiiIpSecId_example; // String | The ID of the Kawaii IPsec connection.

        try {
            apiInstance.deleteKawaiiIpSec(kawaiiId, kawaiiIpSecId);
        } catch (ApiException e) {
            System.err.println("Exception when calling KawaiiIpsecApi#deleteKawaiiIpSec");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
KawaiiIpsecApi *apiInstance = [[KawaiiIpsecApi alloc] init];
String *kawaiiId = kawaiiId_example; // The ID of the Kawaii. (default to null)
String *kawaiiIpSecId = kawaiiIpSecId_example; // The ID of the Kawaii IPsec connection. (default to null)

[apiInstance deleteKawaiiIpSecWith:kawaiiId
    kawaiiIpSecId:kawaiiIpSecId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KowabungaApiDocumentation = require('kowabunga_api_documentation');
var defaultClient = KowabungaApiDocumentation.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new KowabungaApiDocumentation.KawaiiIpsecApi()
var kawaiiId = kawaiiId_example; // {String} The ID of the Kawaii.
var kawaiiIpSecId = kawaiiIpSecId_example; // {String} The ID of the Kawaii IPsec connection.

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteKawaiiIpSec(kawaiiId, kawaiiIpSecId, callback);

using System;
using System.Diagnostics;
using kowabunga.Api;
using kowabunga.Client;
using kowabunga.Model;

namespace Example
{
    public class deleteKawaiiIpSecExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new KawaiiIpsecApi();
            var kawaiiId = kawaiiId_example;  // String | The ID of the Kawaii. (default to null)
            var kawaiiIpSecId = kawaiiIpSecId_example;  // String | The ID of the Kawaii IPsec connection. (default to null)

            try {
                apiInstance.deleteKawaiiIpSec(kawaiiId, kawaiiIpSecId);
            } catch (Exception e) {
                Debug.Print("Exception when calling KawaiiIpsecApi.deleteKawaiiIpSec: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KawaiiIpsecApi();
$kawaiiId = kawaiiId_example; // String | The ID of the Kawaii.
$kawaiiIpSecId = kawaiiIpSecId_example; // String | The ID of the Kawaii IPsec connection.

try {
    $api_instance->deleteKawaiiIpSec($kawaiiId, $kawaiiIpSecId);
} catch (Exception $e) {
    echo 'Exception when calling KawaiiIpsecApi->deleteKawaiiIpSec: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KawaiiIpsecApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KawaiiIpsecApi->new();
my $kawaiiId = kawaiiId_example; # String | The ID of the Kawaii.
my $kawaiiIpSecId = kawaiiIpSecId_example; # String | The ID of the Kawaii IPsec connection.

eval {
    $api_instance->deleteKawaiiIpSec(kawaiiId => $kawaiiId, kawaiiIpSecId => $kawaiiIpSecId);
};
if ($@) {
    warn "Exception when calling KawaiiIpsecApi->deleteKawaiiIpSec: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.KawaiiIpsecApi()
kawaiiId = kawaiiId_example # String | The ID of the Kawaii. (default to null)
kawaiiIpSecId = kawaiiIpSecId_example # String | The ID of the Kawaii IPsec connection. (default to null)

try:
    api_instance.delete_kawaii_ip_sec(kawaiiId, kawaiiIpSecId)
except ApiException as e:
    print("Exception when calling KawaiiIpsecApi->deleteKawaiiIpSec: %s\n" % e)

extern crate KawaiiIpsecApi;

pub fn main() {
    let kawaiiId = kawaiiId_example; // String
    let kawaiiIpSecId = kawaiiIpSecId_example; // String

    let mut context = KawaiiIpsecApi::Context::default();
    let result = client.deleteKawaiiIpSec(kawaiiId, kawaiiIpSecId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KawaiiIpsecApi;

import java.io.File;
import java.util.*;

public class KawaiiIpsecApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        KawaiiIpsecApi apiInstance = new KawaiiIpsecApi();
        String kawaiiId = kawaiiId_example; // String | The ID of the Kawaii.

        try {
            array['String'] result = apiInstance.listKawaiiIpSecs(kawaiiId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KawaiiIpsecApi#listKawaiiIpSecs");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String kawaiiId = new String(); // String | The ID of the Kawaii.

try {
    final result = await api_instance.listKawaiiIpSecs(kawaiiId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->listKawaiiIpSecs: $e\n');
}

import org.openapitools.client.api.KawaiiIpsecApi;

public class KawaiiIpsecApiExample {
    public static void main(String[] args) {
        KawaiiIpsecApi apiInstance = new KawaiiIpsecApi();
        String kawaiiId = kawaiiId_example; // String | The ID of the Kawaii.

        try {
            array['String'] result = apiInstance.listKawaiiIpSecs(kawaiiId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KawaiiIpsecApi#listKawaiiIpSecs");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
KawaiiIpsecApi *apiInstance = [[KawaiiIpsecApi alloc] init];
String *kawaiiId = kawaiiId_example; // The ID of the Kawaii. (default to null)

[apiInstance listKawaiiIpSecsWith:kawaiiId
              completionHandler: ^(array['String'] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KowabungaApiDocumentation = require('kowabunga_api_documentation');
var defaultClient = KowabungaApiDocumentation.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new KowabungaApiDocumentation.KawaiiIpsecApi()
var kawaiiId = kawaiiId_example; // {String} The ID of the Kawaii.

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listKawaiiIpSecs(kawaiiId, callback);

using System;
using System.Diagnostics;
using kowabunga.Api;
using kowabunga.Client;
using kowabunga.Model;

namespace Example
{
    public class listKawaiiIpSecsExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new KawaiiIpsecApi();
            var kawaiiId = kawaiiId_example;  // String | The ID of the Kawaii. (default to null)

            try {
                array['String'] result = apiInstance.listKawaiiIpSecs(kawaiiId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KawaiiIpsecApi.listKawaiiIpSecs: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KawaiiIpsecApi();
$kawaiiId = kawaiiId_example; // String | The ID of the Kawaii.

try {
    $result = $api_instance->listKawaiiIpSecs($kawaiiId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling KawaiiIpsecApi->listKawaiiIpSecs: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KawaiiIpsecApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KawaiiIpsecApi->new();
my $kawaiiId = kawaiiId_example; # String | The ID of the Kawaii.

eval {
    my $result = $api_instance->listKawaiiIpSecs(kawaiiId => $kawaiiId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KawaiiIpsecApi->listKawaiiIpSecs: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.KawaiiIpsecApi()
kawaiiId = kawaiiId_example # String | The ID of the Kawaii. (default to null)

try:
    api_response = api_instance.list_kawaii_ip_secs(kawaiiId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KawaiiIpsecApi->listKawaiiIpSecs: %s\n" % e)

extern crate KawaiiIpsecApi;

pub fn main() {
    let kawaiiId = kawaiiId_example; // String

    let mut context = KawaiiIpsecApi::Context::default();
    let result = client.listKawaiiIpSecs(kawaiiId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KawaiiIpsecApi;

import java.io.File;
import java.util.*;

public class KawaiiIpsecApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        KawaiiIpsecApi apiInstance = new KawaiiIpsecApi();
        String kawaiiId = kawaiiId_example; // String | The ID of the Kawaii.
        String kawaiiIpSecId = kawaiiIpSecId_example; // String | The ID of the Kawaii IPsec connection.

        try {
            KawaiiIpSec result = apiInstance.readKawaiiIpSec(kawaiiId, kawaiiIpSecId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KawaiiIpsecApi#readKawaiiIpSec");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String kawaiiId = new String(); // String | The ID of the Kawaii.
final String kawaiiIpSecId = new String(); // String | The ID of the Kawaii IPsec connection.

try {
    final result = await api_instance.readKawaiiIpSec(kawaiiId, kawaiiIpSecId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->readKawaiiIpSec: $e\n');
}

import org.openapitools.client.api.KawaiiIpsecApi;

public class KawaiiIpsecApiExample {
    public static void main(String[] args) {
        KawaiiIpsecApi apiInstance = new KawaiiIpsecApi();
        String kawaiiId = kawaiiId_example; // String | The ID of the Kawaii.
        String kawaiiIpSecId = kawaiiIpSecId_example; // String | The ID of the Kawaii IPsec connection.

        try {
            KawaiiIpSec result = apiInstance.readKawaiiIpSec(kawaiiId, kawaiiIpSecId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KawaiiIpsecApi#readKawaiiIpSec");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
KawaiiIpsecApi *apiInstance = [[KawaiiIpsecApi alloc] init];
String *kawaiiId = kawaiiId_example; // The ID of the Kawaii. (default to null)
String *kawaiiIpSecId = kawaiiIpSecId_example; // The ID of the Kawaii IPsec connection. (default to null)

[apiInstance readKawaiiIpSecWith:kawaiiId
    kawaiiIpSecId:kawaiiIpSecId
              completionHandler: ^(KawaiiIpSec output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KowabungaApiDocumentation = require('kowabunga_api_documentation');
var defaultClient = KowabungaApiDocumentation.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new KowabungaApiDocumentation.KawaiiIpsecApi()
var kawaiiId = kawaiiId_example; // {String} The ID of the Kawaii.
var kawaiiIpSecId = kawaiiIpSecId_example; // {String} The ID of the Kawaii IPsec connection.

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.readKawaiiIpSec(kawaiiId, kawaiiIpSecId, callback);

using System;
using System.Diagnostics;
using kowabunga.Api;
using kowabunga.Client;
using kowabunga.Model;

namespace Example
{
    public class readKawaiiIpSecExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new KawaiiIpsecApi();
            var kawaiiId = kawaiiId_example;  // String | The ID of the Kawaii. (default to null)
            var kawaiiIpSecId = kawaiiIpSecId_example;  // String | The ID of the Kawaii IPsec connection. (default to null)

            try {
                KawaiiIpSec result = apiInstance.readKawaiiIpSec(kawaiiId, kawaiiIpSecId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KawaiiIpsecApi.readKawaiiIpSec: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KawaiiIpsecApi();
$kawaiiId = kawaiiId_example; // String | The ID of the Kawaii.
$kawaiiIpSecId = kawaiiIpSecId_example; // String | The ID of the Kawaii IPsec connection.

try {
    $result = $api_instance->readKawaiiIpSec($kawaiiId, $kawaiiIpSecId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling KawaiiIpsecApi->readKawaiiIpSec: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KawaiiIpsecApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KawaiiIpsecApi->new();
my $kawaiiId = kawaiiId_example; # String | The ID of the Kawaii.
my $kawaiiIpSecId = kawaiiIpSecId_example; # String | The ID of the Kawaii IPsec connection.

eval {
    my $result = $api_instance->readKawaiiIpSec(kawaiiId => $kawaiiId, kawaiiIpSecId => $kawaiiIpSecId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KawaiiIpsecApi->readKawaiiIpSec: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.KawaiiIpsecApi()
kawaiiId = kawaiiId_example # String | The ID of the Kawaii. (default to null)
kawaiiIpSecId = kawaiiIpSecId_example # String | The ID of the Kawaii IPsec connection. (default to null)

try:
    api_response = api_instance.read_kawaii_ip_sec(kawaiiId, kawaiiIpSecId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KawaiiIpsecApi->readKawaiiIpSec: %s\n" % e)

extern crate KawaiiIpsecApi;

pub fn main() {
    let kawaiiId = kawaiiId_example; // String
    let kawaiiIpSecId = kawaiiIpSecId_example; // String

    let mut context = KawaiiIpsecApi::Context::default();
    let result = client.readKawaiiIpSec(kawaiiId, kawaiiIpSecId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KawaiiIpsecApi;

import java.io.File;
import java.util.*;

public class KawaiiIpsecApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        KawaiiIpsecApi apiInstance = new KawaiiIpsecApi();
        String kawaiiId = kawaiiId_example; // String | The ID of the Kawaii.
        String kawaiiIpSecId = kawaiiIpSecId_example; // String | The ID of the Kawaii IPsec connection.
        KawaiiIpSec kawaiiIpSec = ; // KawaiiIpSec | 

        try {
            KawaiiIpSec result = apiInstance.updateKawaiiIpSec(kawaiiId, kawaiiIpSecId, kawaiiIpSec);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KawaiiIpsecApi#updateKawaiiIpSec");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String kawaiiId = new String(); // String | The ID of the Kawaii.
final String kawaiiIpSecId = new String(); // String | The ID of the Kawaii IPsec connection.
final KawaiiIpSec kawaiiIpSec = new KawaiiIpSec(); // KawaiiIpSec | 

try {
    final result = await api_instance.updateKawaiiIpSec(kawaiiId, kawaiiIpSecId, kawaiiIpSec);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->updateKawaiiIpSec: $e\n');
}

import org.openapitools.client.api.KawaiiIpsecApi;

public class KawaiiIpsecApiExample {
    public static void main(String[] args) {
        KawaiiIpsecApi apiInstance = new KawaiiIpsecApi();
        String kawaiiId = kawaiiId_example; // String | The ID of the Kawaii.
        String kawaiiIpSecId = kawaiiIpSecId_example; // String | The ID of the Kawaii IPsec connection.
        KawaiiIpSec kawaiiIpSec = ; // KawaiiIpSec | 

        try {
            KawaiiIpSec result = apiInstance.updateKawaiiIpSec(kawaiiId, kawaiiIpSecId, kawaiiIpSec);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KawaiiIpsecApi#updateKawaiiIpSec");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
KawaiiIpsecApi *apiInstance = [[KawaiiIpsecApi alloc] init];
String *kawaiiId = kawaiiId_example; // The ID of the Kawaii. (default to null)
String *kawaiiIpSecId = kawaiiIpSecId_example; // The ID of the Kawaii IPsec connection. (default to null)
KawaiiIpSec *kawaiiIpSec = ; // 

[apiInstance updateKawaiiIpSecWith:kawaiiId
    kawaiiIpSecId:kawaiiIpSecId
    kawaiiIpSec:kawaiiIpSec
              completionHandler: ^(KawaiiIpSec output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KowabungaApiDocumentation = require('kowabunga_api_documentation');
var defaultClient = KowabungaApiDocumentation.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new KowabungaApiDocumentation.KawaiiIpsecApi()
var kawaiiId = kawaiiId_example; // {String} The ID of the Kawaii.
var kawaiiIpSecId = kawaiiIpSecId_example; // {String} The ID of the Kawaii IPsec connection.
var kawaiiIpSec = ; // {KawaiiIpSec} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateKawaiiIpSec(kawaiiId, kawaiiIpSecId, kawaiiIpSec, callback);

using System;
using System.Diagnostics;
using kowabunga.Api;
using kowabunga.Client;
using kowabunga.Model;

namespace Example
{
    public class updateKawaiiIpSecExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new KawaiiIpsecApi();
            var kawaiiId = kawaiiId_example;  // String | The ID of the Kawaii. (default to null)
            var kawaiiIpSecId = kawaiiIpSecId_example;  // String | The ID of the Kawaii IPsec connection. (default to null)
            var kawaiiIpSec = new KawaiiIpSec(); // KawaiiIpSec | 

            try {
                KawaiiIpSec result = apiInstance.updateKawaiiIpSec(kawaiiId, kawaiiIpSecId, kawaiiIpSec);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KawaiiIpsecApi.updateKawaiiIpSec: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KawaiiIpsecApi();
$kawaiiId = kawaiiId_example; // String | The ID of the Kawaii.
$kawaiiIpSecId = kawaiiIpSecId_example; // String | The ID of the Kawaii IPsec connection.
$kawaiiIpSec = ; // KawaiiIpSec | 

try {
    $result = $api_instance->updateKawaiiIpSec($kawaiiId, $kawaiiIpSecId, $kawaiiIpSec);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling KawaiiIpsecApi->updateKawaiiIpSec: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KawaiiIpsecApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KawaiiIpsecApi->new();
my $kawaiiId = kawaiiId_example; # String | The ID of the Kawaii.
my $kawaiiIpSecId = kawaiiIpSecId_example; # String | The ID of the Kawaii IPsec connection.
my $kawaiiIpSec = WWW::OPenAPIClient::Object::KawaiiIpSec->new(); # KawaiiIpSec | 

eval {
    my $result = $api_instance->updateKawaiiIpSec(kawaiiId => $kawaiiId, kawaiiIpSecId => $kawaiiIpSecId, kawaiiIpSec => $kawaiiIpSec);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KawaiiIpsecApi->updateKawaiiIpSec: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.KawaiiIpsecApi()
kawaiiId = kawaiiId_example # String | The ID of the Kawaii. (default to null)
kawaiiIpSecId = kawaiiIpSecId_example # String | The ID of the Kawaii IPsec connection. (default to null)
kawaiiIpSec =  # KawaiiIpSec | 

try:
    api_response = api_instance.update_kawaii_ip_sec(kawaiiId, kawaiiIpSecId, kawaiiIpSec)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KawaiiIpsecApi->updateKawaiiIpSec: %s\n" % e)

extern crate KawaiiIpsecApi;

pub fn main() {
    let kawaiiId = kawaiiId_example; // String
    let kawaiiIpSecId = kawaiiIpSecId_example; // String
    let kawaiiIpSec = ; // KawaiiIpSec

    let mut context = KawaiiIpsecApi::Context::default();
    let result = client.updateKawaiiIpSec(kawaiiId, kawaiiIpSecId, kawaiiIpSec, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KiwiApi;

import java.io.File;
import java.util.*;

public class KiwiApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        KiwiApi apiInstance = new KiwiApi();
        String regionId = regionId_example; // String | The ID of the region.
        Kiwi kiwi = ; // Kiwi | 

        try {
            Kiwi result = apiInstance.createKiwi(regionId, kiwi);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KiwiApi#createKiwi");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String regionId = new String(); // String | The ID of the region.
final Kiwi kiwi = new Kiwi(); // Kiwi | 

try {
    final result = await api_instance.createKiwi(regionId, kiwi);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->createKiwi: $e\n');
}

import org.openapitools.client.api.KiwiApi;

public class KiwiApiExample {
    public static void main(String[] args) {
        KiwiApi apiInstance = new KiwiApi();
        String regionId = regionId_example; // String | The ID of the region.
        Kiwi kiwi = ; // Kiwi | 

        try {
            Kiwi result = apiInstance.createKiwi(regionId, kiwi);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KiwiApi#createKiwi");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
KiwiApi *apiInstance = [[KiwiApi alloc] init];
String *regionId = regionId_example; // The ID of the region. (default to null)
Kiwi *kiwi = ; // 

[apiInstance createKiwiWith:regionId
    kiwi:kiwi
              completionHandler: ^(Kiwi output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KowabungaApiDocumentation = require('kowabunga_api_documentation');
var defaultClient = KowabungaApiDocumentation.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new KowabungaApiDocumentation.KiwiApi()
var regionId = regionId_example; // {String} The ID of the region.
var kiwi = ; // {Kiwi} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createKiwi(regionId, kiwi, callback);

using System;
using System.Diagnostics;
using kowabunga.Api;
using kowabunga.Client;
using kowabunga.Model;

namespace Example
{
    public class createKiwiExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new KiwiApi();
            var regionId = regionId_example;  // String | The ID of the region. (default to null)
            var kiwi = new Kiwi(); // Kiwi | 

            try {
                Kiwi result = apiInstance.createKiwi(regionId, kiwi);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KiwiApi.createKiwi: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KiwiApi();
$regionId = regionId_example; // String | The ID of the region.
$kiwi = ; // Kiwi | 

try {
    $result = $api_instance->createKiwi($regionId, $kiwi);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling KiwiApi->createKiwi: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KiwiApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KiwiApi->new();
my $regionId = regionId_example; # String | The ID of the region.
my $kiwi = WWW::OPenAPIClient::Object::Kiwi->new(); # Kiwi | 

eval {
    my $result = $api_instance->createKiwi(regionId => $regionId, kiwi => $kiwi);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KiwiApi->createKiwi: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.KiwiApi()
regionId = regionId_example # String | The ID of the region. (default to null)
kiwi =  # Kiwi | 

try:
    api_response = api_instance.create_kiwi(regionId, kiwi)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KiwiApi->createKiwi: %s\n" % e)

extern crate KiwiApi;

pub fn main() {
    let regionId = regionId_example; // String
    let kiwi = ; // Kiwi

    let mut context = KiwiApi::Context::default();
    let result = client.createKiwi(regionId, kiwi, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KiwiApi;

import java.io.File;
import java.util.*;

public class KiwiApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        KiwiApi apiInstance = new KiwiApi();
        String kiwiId = kiwiId_example; // String | The ID of the Kiwi (Kowabunga Inner Wan Interface) provides edge-network services..

        try {
            apiInstance.deleteKiwi(kiwiId);
        } catch (ApiException e) {
            System.err.println("Exception when calling KiwiApi#deleteKiwi");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String kiwiId = new String(); // String | The ID of the Kiwi (Kowabunga Inner Wan Interface) provides edge-network services..

try {
    final result = await api_instance.deleteKiwi(kiwiId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteKiwi: $e\n');
}

import org.openapitools.client.api.KiwiApi;

public class KiwiApiExample {
    public static void main(String[] args) {
        KiwiApi apiInstance = new KiwiApi();
        String kiwiId = kiwiId_example; // String | The ID of the Kiwi (Kowabunga Inner Wan Interface) provides edge-network services..

        try {
            apiInstance.deleteKiwi(kiwiId);
        } catch (ApiException e) {
            System.err.println("Exception when calling KiwiApi#deleteKiwi");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
KiwiApi *apiInstance = [[KiwiApi alloc] init];
String *kiwiId = kiwiId_example; // The ID of the Kiwi (Kowabunga Inner Wan Interface) provides edge-network services.. (default to null)

[apiInstance deleteKiwiWith:kiwiId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KowabungaApiDocumentation = require('kowabunga_api_documentation');
var defaultClient = KowabungaApiDocumentation.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new KowabungaApiDocumentation.KiwiApi()
var kiwiId = kiwiId_example; // {String} The ID of the Kiwi (Kowabunga Inner Wan Interface) provides edge-network services..

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteKiwi(kiwiId, callback);

using System;
using System.Diagnostics;
using kowabunga.Api;
using kowabunga.Client;
using kowabunga.Model;

namespace Example
{
    public class deleteKiwiExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new KiwiApi();
            var kiwiId = kiwiId_example;  // String | The ID of the Kiwi (Kowabunga Inner Wan Interface) provides edge-network services.. (default to null)

            try {
                apiInstance.deleteKiwi(kiwiId);
            } catch (Exception e) {
                Debug.Print("Exception when calling KiwiApi.deleteKiwi: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KiwiApi();
$kiwiId = kiwiId_example; // String | The ID of the Kiwi (Kowabunga Inner Wan Interface) provides edge-network services..

try {
    $api_instance->deleteKiwi($kiwiId);
} catch (Exception $e) {
    echo 'Exception when calling KiwiApi->deleteKiwi: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KiwiApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KiwiApi->new();
my $kiwiId = kiwiId_example; # String | The ID of the Kiwi (Kowabunga Inner Wan Interface) provides edge-network services..

eval {
    $api_instance->deleteKiwi(kiwiId => $kiwiId);
};
if ($@) {
    warn "Exception when calling KiwiApi->deleteKiwi: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.KiwiApi()
kiwiId = kiwiId_example # String | The ID of the Kiwi (Kowabunga Inner Wan Interface) provides edge-network services.. (default to null)

try:
    api_instance.delete_kiwi(kiwiId)
except ApiException as e:
    print("Exception when calling KiwiApi->deleteKiwi: %s\n" % e)

extern crate KiwiApi;

pub fn main() {
    let kiwiId = kiwiId_example; // String

    let mut context = KiwiApi::Context::default();
    let result = client.deleteKiwi(kiwiId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KiwiApi;

import java.io.File;
import java.util.*;

public class KiwiApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        KiwiApi apiInstance = new KiwiApi();

        try {
            array['String'] result = apiInstance.listKiwis();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KiwiApi#listKiwis");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.listKiwis();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->listKiwis: $e\n');
}

import org.openapitools.client.api.KiwiApi;

public class KiwiApiExample {
    public static void main(String[] args) {
        KiwiApi apiInstance = new KiwiApi();

        try {
            array['String'] result = apiInstance.listKiwis();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KiwiApi#listKiwis");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
KiwiApi *apiInstance = [[KiwiApi alloc] init];

[apiInstance listKiwisWithCompletionHandler: 
              ^(array['String'] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var KowabungaApiDocumentation = require('kowabunga_api_documentation');
var defaultClient = KowabungaApiDocumentation.ApiClient.instance;

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new KowabungaApiDocumentation.KiwiApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listKiwis(callback);

using System;
using System.Diagnostics;
using kowabunga.Api;
using kowabunga.Client;
using kowabunga.Model;

namespace Example
{
    public class listKiwisExample
    {
        public void main()
        {
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new KiwiApi();

            try {
                array['String'] result = apiInstance.listKiwis();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KiwiApi.listKiwis: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KiwiApi();

try {
    $result = $api_instance->listKiwis();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling KiwiApi->listKiwis: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KiwiApi;

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KiwiApi->new();

eval {
    my $result = $api_instance->listKiwis();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KiwiApi->listKiwis: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.KiwiApi()

try:
    api_response = api_instance.list_kiwis()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KiwiApi->listKiwis: %s\n" % e)

extern crate KiwiApi;

pub fn main() {

    let mut context = KiwiApi::Context::default();
    let result = client.listKiwis(&context).wait();

    println!("{:?}", result);
}